| // basisu_comp.cpp |
| // Copyright (C) 2019-2024 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. |
| #include "basisu_comp.h" |
| #include "basisu_enc.h" |
| #include <unordered_set> |
| #include <atomic> |
| #include <map> |
| |
| //#define UASTC_HDR_DEBUG_SAVE_CATEGORIZED_BLOCKS |
| |
| // basisu_transcoder.cpp is where basisu_miniz lives now, we just need the declarations here. |
| #define MINIZ_NO_ZLIB_COMPATIBLE_NAMES |
| #include "basisu_miniz.h" |
| |
| #include "basisu_opencl.h" |
| |
| #include "../transcoder/basisu_astc_hdr_core.h" |
| |
| #if !BASISD_SUPPORT_KTX2 |
| #error BASISD_SUPPORT_KTX2 must be enabled (set to 1). |
| #endif |
| |
| #if BASISD_SUPPORT_KTX2_ZSTD |
| #include "../zstd/zstd.h" |
| #endif |
| |
| // Set to 1 to disable the mipPadding alignment workaround (which only seems to be needed when no key-values are written at all) |
| #define BASISU_DISABLE_KTX2_ALIGNMENT_WORKAROUND (0) |
| |
| // Set to 1 to disable writing all KTX2 key values, triggering an early validator bug. |
| #define BASISU_DISABLE_KTX2_KEY_VALUES (0) |
| |
| using namespace buminiz; |
| |
| #define BASISU_USE_STB_IMAGE_RESIZE_FOR_MIPMAP_GEN 0 |
| #define DEBUG_CROP_TEXTURE_TO_64x64 (0) |
| #define DEBUG_RESIZE_TEXTURE (0) |
| #define DEBUG_EXTRACT_SINGLE_BLOCK (0) |
| |
| namespace basisu |
| { |
| basis_compressor::basis_compressor() : |
| m_pOpenCL_context(nullptr), |
| m_basis_file_size(0), |
| m_basis_bits_per_texel(0.0f), |
| m_total_blocks(0), |
| m_any_source_image_has_alpha(false), |
| m_opencl_failed(false) |
| { |
| debug_printf("basis_compressor::basis_compressor\n"); |
| |
| assert(g_library_initialized); |
| } |
| |
| basis_compressor::~basis_compressor() |
| { |
| if (m_pOpenCL_context) |
| { |
| opencl_destroy_context(m_pOpenCL_context); |
| m_pOpenCL_context = nullptr; |
| } |
| } |
| |
| void basis_compressor::check_for_hdr_inputs() |
| { |
| if ((!m_params.m_source_filenames.size()) && (!m_params.m_source_images.size())) |
| { |
| if (m_params.m_source_images_hdr.size()) |
| { |
| // Assume they want UASTC HDR if they've specified any HDR source images. |
| m_params.m_hdr = true; |
| } |
| } |
| |
| if (!m_params.m_hdr) |
| { |
| // See if any files are .EXR or .HDR, if so switch the compressor to UASTC HDR mode. |
| for (uint32_t i = 0; i < m_params.m_source_filenames.size(); i++) |
| { |
| std::string filename; |
| string_get_filename(m_params.m_source_filenames[i].c_str(), filename); |
| |
| std::string ext(string_get_extension(filename)); |
| string_tolower(ext); |
| |
| if ((ext == "exr") || (ext == "hdr")) |
| { |
| m_params.m_hdr = true; |
| break; |
| } |
| } |
| } |
| |
| if (m_params.m_hdr) |
| { |
| if (m_params.m_source_alpha_filenames.size()) |
| { |
| debug_printf("Warning: Alpha channel image filenames are not supported in UASTC HDR mode.\n"); |
| m_params.m_source_alpha_filenames.clear(); |
| } |
| } |
| |
| if (m_params.m_hdr) |
| m_params.m_uastc = true; |
| } |
| |
| bool basis_compressor::sanity_check_input_params() |
| { |
| // Check for no source filenames specified. |
| if ((m_params.m_read_source_images) && (!m_params.m_source_filenames.size())) |
| { |
| assert(0); |
| return false; |
| } |
| |
| // See if they've specified any source filenames, but didn't tell us to read them. |
| if ((!m_params.m_read_source_images) && (m_params.m_source_filenames.size())) |
| { |
| assert(0); |
| return false; |
| } |
| |
| // Sanity check the input image parameters. |
| if (m_params.m_read_source_images) |
| { |
| // Caller can't specify their own images if they want us to read source images from files. |
| if (m_params.m_source_images.size() || m_params.m_source_images_hdr.size()) |
| { |
| assert(0); |
| return false; |
| } |
| |
| if (m_params.m_source_mipmap_images.size() || m_params.m_source_mipmap_images_hdr.size()) |
| { |
| assert(0); |
| return false; |
| } |
| } |
| else |
| { |
| // They didn't tell us to read any source files, so check for no LDR/HDR source images. |
| if (!m_params.m_source_images.size() && !m_params.m_source_images_hdr.size()) |
| { |
| assert(0); |
| return false; |
| } |
| |
| // Now we know we've been supplied LDR and/or HDR source images, check for LDR vs. HDR conflicts. |
| |
| if (m_params.m_source_images.size()) |
| { |
| // They've supplied LDR images, so make sure they also haven't specified HDR input images. |
| if (m_params.m_source_images_hdr.size() || m_params.m_source_mipmap_images_hdr.size()) |
| { |
| assert(0); |
| return false; |
| } |
| } |
| else |
| { |
| // No LDR images, so make sure they haven't specified any LDR mipmaps. |
| if (m_params.m_source_mipmap_images.size()) |
| { |
| assert(0); |
| return false; |
| } |
| |
| // No LDR images, so ensure they've supplied some HDR images to process. |
| if (!m_params.m_source_images_hdr.size()) |
| { |
| assert(0); |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::init(const basis_compressor_params ¶ms) |
| { |
| debug_printf("basis_compressor::init\n"); |
| |
| if (!g_library_initialized) |
| { |
| error_printf("basis_compressor::init: basisu_encoder_init() MUST be called before using any encoder functionality!\n"); |
| return false; |
| } |
| |
| if (!params.m_pJob_pool) |
| { |
| error_printf("basis_compressor::init: A non-null job_pool pointer must be specified\n"); |
| return false; |
| } |
| |
| m_params = params; |
| |
| if ((m_params.m_compute_stats) && (!m_params.m_validate_output_data)) |
| m_params.m_validate_output_data = true; |
| |
| check_for_hdr_inputs(); |
| |
| if (m_params.m_debug) |
| { |
| debug_printf("basis_compressor::init:\n"); |
| |
| #define PRINT_BOOL_VALUE(v) debug_printf("%s: %u %u\n", BASISU_STRINGIZE2(v), static_cast<int>(m_params.v), m_params.v.was_changed()); |
| #define PRINT_INT_VALUE(v) debug_printf("%s: %i %u\n", BASISU_STRINGIZE2(v), static_cast<int>(m_params.v), m_params.v.was_changed()); |
| #define PRINT_UINT_VALUE(v) debug_printf("%s: %u %u\n", BASISU_STRINGIZE2(v), static_cast<uint32_t>(m_params.v), m_params.v.was_changed()); |
| #define PRINT_FLOAT_VALUE(v) debug_printf("%s: %f %u\n", BASISU_STRINGIZE2(v), static_cast<float>(m_params.v), m_params.v.was_changed()); |
| |
| debug_printf("Source LDR images: %u, HDR images: %u, filenames: %u, alpha filenames: %i, LDR mipmap images: %u, HDR mipmap images: %u\n", |
| m_params.m_source_images.size(), m_params.m_source_images_hdr.size(), |
| m_params.m_source_filenames.size(), m_params.m_source_alpha_filenames.size(), |
| m_params.m_source_mipmap_images.size(), m_params.m_source_mipmap_images_hdr.size()); |
| |
| if (m_params.m_source_mipmap_images.size()) |
| { |
| debug_printf("m_source_mipmap_images array sizes:\n"); |
| for (uint32_t i = 0; i < m_params.m_source_mipmap_images.size(); i++) |
| debug_printf("%u ", m_params.m_source_mipmap_images[i].size()); |
| debug_printf("\n"); |
| } |
| |
| if (m_params.m_source_mipmap_images_hdr.size()) |
| { |
| debug_printf("m_source_mipmap_images_hdr array sizes:\n"); |
| for (uint32_t i = 0; i < m_params.m_source_mipmap_images_hdr.size(); i++) |
| debug_printf("%u ", m_params.m_source_mipmap_images_hdr[i].size()); |
| debug_printf("\n"); |
| } |
| |
| PRINT_BOOL_VALUE(m_hdr); |
| PRINT_BOOL_VALUE(m_uastc); |
| PRINT_BOOL_VALUE(m_use_opencl); |
| PRINT_BOOL_VALUE(m_y_flip); |
| PRINT_BOOL_VALUE(m_debug); |
| PRINT_BOOL_VALUE(m_validate_etc1s); |
| PRINT_BOOL_VALUE(m_debug_images); |
| PRINT_INT_VALUE(m_compression_level); |
| PRINT_BOOL_VALUE(m_perceptual); |
| PRINT_BOOL_VALUE(m_no_endpoint_rdo); |
| PRINT_BOOL_VALUE(m_no_selector_rdo); |
| PRINT_BOOL_VALUE(m_read_source_images); |
| PRINT_BOOL_VALUE(m_write_output_basis_or_ktx2_files); |
| PRINT_BOOL_VALUE(m_compute_stats); |
| PRINT_BOOL_VALUE(m_check_for_alpha); |
| PRINT_BOOL_VALUE(m_force_alpha); |
| debug_printf("swizzle: %d,%d,%d,%d\n", |
| m_params.m_swizzle[0], |
| m_params.m_swizzle[1], |
| m_params.m_swizzle[2], |
| m_params.m_swizzle[3]); |
| PRINT_BOOL_VALUE(m_renormalize); |
| PRINT_BOOL_VALUE(m_multithreading); |
| PRINT_BOOL_VALUE(m_disable_hierarchical_endpoint_codebooks); |
| |
| PRINT_FLOAT_VALUE(m_endpoint_rdo_thresh); |
| PRINT_FLOAT_VALUE(m_selector_rdo_thresh); |
| |
| PRINT_BOOL_VALUE(m_mip_gen); |
| PRINT_BOOL_VALUE(m_mip_renormalize); |
| PRINT_BOOL_VALUE(m_mip_wrapping); |
| PRINT_BOOL_VALUE(m_mip_fast); |
| PRINT_BOOL_VALUE(m_mip_srgb); |
| PRINT_FLOAT_VALUE(m_mip_premultiplied); |
| PRINT_FLOAT_VALUE(m_mip_scale); |
| PRINT_INT_VALUE(m_mip_smallest_dimension); |
| debug_printf("m_mip_filter: %s\n", m_params.m_mip_filter.c_str()); |
| |
| debug_printf("m_max_endpoint_clusters: %u\n", m_params.m_max_endpoint_clusters); |
| debug_printf("m_max_selector_clusters: %u\n", m_params.m_max_selector_clusters); |
| debug_printf("m_quality_level: %i\n", m_params.m_quality_level); |
| debug_printf("UASTC HDR quality level: %u\n", m_params.m_uastc_hdr_options.m_level); |
| |
| debug_printf("m_tex_type: %u\n", m_params.m_tex_type); |
| debug_printf("m_userdata0: 0x%X, m_userdata1: 0x%X\n", m_params.m_userdata0, m_params.m_userdata1); |
| debug_printf("m_us_per_frame: %i (%f fps)\n", m_params.m_us_per_frame, m_params.m_us_per_frame ? 1.0f / (m_params.m_us_per_frame / 1000000.0f) : 0); |
| debug_printf("m_pack_uastc_flags: 0x%X\n", m_params.m_pack_uastc_flags); |
| |
| PRINT_BOOL_VALUE(m_rdo_uastc); |
| PRINT_FLOAT_VALUE(m_rdo_uastc_quality_scalar); |
| PRINT_INT_VALUE(m_rdo_uastc_dict_size); |
| PRINT_FLOAT_VALUE(m_rdo_uastc_max_allowed_rms_increase_ratio); |
| PRINT_FLOAT_VALUE(m_rdo_uastc_skip_block_rms_thresh); |
| PRINT_FLOAT_VALUE(m_rdo_uastc_max_smooth_block_error_scale); |
| PRINT_FLOAT_VALUE(m_rdo_uastc_smooth_block_max_std_dev); |
| PRINT_BOOL_VALUE(m_rdo_uastc_favor_simpler_modes_in_rdo_mode) |
| PRINT_BOOL_VALUE(m_rdo_uastc_multithreading); |
| |
| PRINT_INT_VALUE(m_resample_width); |
| PRINT_INT_VALUE(m_resample_height); |
| PRINT_FLOAT_VALUE(m_resample_factor); |
| |
| debug_printf("Has global codebooks: %u\n", m_params.m_pGlobal_codebooks ? 1 : 0); |
| if (m_params.m_pGlobal_codebooks) |
| { |
| debug_printf("Global codebook endpoints: %u selectors: %u\n", m_params.m_pGlobal_codebooks->get_endpoints().size(), m_params.m_pGlobal_codebooks->get_selectors().size()); |
| } |
| |
| PRINT_BOOL_VALUE(m_create_ktx2_file); |
| |
| debug_printf("KTX2 UASTC supercompression: %u\n", m_params.m_ktx2_uastc_supercompression); |
| debug_printf("KTX2 Zstd supercompression level: %i\n", (int)m_params.m_ktx2_zstd_supercompression_level); |
| debug_printf("KTX2 sRGB transfer func: %u\n", (int)m_params.m_ktx2_srgb_transfer_func); |
| debug_printf("Total KTX2 key values: %u\n", m_params.m_ktx2_key_values.size()); |
| for (uint32_t i = 0; i < m_params.m_ktx2_key_values.size(); i++) |
| { |
| debug_printf("Key: \"%s\"\n", m_params.m_ktx2_key_values[i].m_key.data()); |
| debug_printf("Value size: %u\n", m_params.m_ktx2_key_values[i].m_value.size()); |
| } |
| |
| PRINT_BOOL_VALUE(m_validate_output_data); |
| PRINT_BOOL_VALUE(m_hdr_ldr_srgb_to_linear_conversion); |
| debug_printf("Allow UASTC HDR uber mode: %u\n", m_params.m_uastc_hdr_options.m_allow_uber_mode); |
| PRINT_BOOL_VALUE(m_hdr_favor_astc); |
| |
| #undef PRINT_BOOL_VALUE |
| #undef PRINT_INT_VALUE |
| #undef PRINT_UINT_VALUE |
| #undef PRINT_FLOAT_VALUE |
| } |
| |
| if (!sanity_check_input_params()) |
| return false; |
| |
| if ((m_params.m_use_opencl) && opencl_is_available() && !m_pOpenCL_context && !m_opencl_failed) |
| { |
| m_pOpenCL_context = opencl_create_context(); |
| if (!m_pOpenCL_context) |
| m_opencl_failed = true; |
| } |
| |
| return true; |
| } |
| |
| basis_compressor::error_code basis_compressor::process() |
| { |
| debug_printf("basis_compressor::process\n"); |
| |
| if (!read_dds_source_images()) |
| return cECFailedReadingSourceImages; |
| |
| if (!read_source_images()) |
| return cECFailedReadingSourceImages; |
| |
| if (!validate_texture_type_constraints()) |
| return cECFailedValidating; |
| |
| if (m_params.m_create_ktx2_file) |
| { |
| if (!validate_ktx2_constraints()) |
| { |
| error_printf("Inputs do not satisfy .KTX2 texture constraints: all source images must be the same resolution and have the same number of mipmap levels.\n"); |
| return cECFailedValidating; |
| } |
| } |
| |
| if (!extract_source_blocks()) |
| return cECFailedFrontEnd; |
| |
| if (m_params.m_hdr) |
| { |
| // UASTC HDR |
| if (m_params.m_status_output) |
| printf("Mode: UASTC HDR Level %u\n", m_params.m_uastc_hdr_options.m_level); |
| |
| error_code ec = encode_slices_to_uastc_hdr(); |
| if (ec != cECSuccess) |
| return ec; |
| } |
| else if (m_params.m_uastc) |
| { |
| // UASTC |
| if (m_params.m_status_output) |
| printf("Mode: UASTC LDR Level %u\n", m_params.m_pack_uastc_flags & cPackUASTCLevelMask); |
| |
| error_code ec = encode_slices_to_uastc(); |
| if (ec != cECSuccess) |
| return ec; |
| } |
| else |
| { |
| // ETC1S |
| if (m_params.m_status_output) |
| printf("Mode: ETC1S Quality %i, Level %i\n", m_params.m_quality_level, (int)m_params.m_compression_level); |
| |
| if (!process_frontend()) |
| return cECFailedFrontEnd; |
| |
| if (!extract_frontend_texture_data()) |
| return cECFailedFontendExtract; |
| |
| if (!process_backend()) |
| return cECFailedBackend; |
| } |
| |
| if (!create_basis_file_and_transcode()) |
| return cECFailedCreateBasisFile; |
| |
| if (m_params.m_create_ktx2_file) |
| { |
| if (!create_ktx2_file()) |
| return cECFailedCreateKTX2File; |
| } |
| |
| if (!write_output_files_and_compute_stats()) |
| return cECFailedWritingOutput; |
| |
| return cECSuccess; |
| } |
| |
| basis_compressor::error_code basis_compressor::encode_slices_to_uastc_hdr() |
| { |
| debug_printf("basis_compressor::encode_slices_to_uastc_hdr\n"); |
| |
| interval_timer tm; |
| tm.start(); |
| |
| m_uastc_slice_textures.resize(m_slice_descs.size()); |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| m_uastc_slice_textures[slice_index].init(texture_format::cUASTC_HDR_4x4, m_slice_descs[slice_index].m_orig_width, m_slice_descs[slice_index].m_orig_height); |
| |
| m_uastc_backend_output.m_tex_format = basist::basis_tex_format::cUASTC_HDR_4x4; |
| m_uastc_backend_output.m_etc1s = false; |
| m_uastc_backend_output.m_slice_desc = m_slice_descs; |
| m_uastc_backend_output.m_slice_image_data.resize(m_slice_descs.size()); |
| m_uastc_backend_output.m_slice_image_crcs.resize(m_slice_descs.size()); |
| |
| if (!m_params.m_perceptual) |
| { |
| m_params.m_uastc_hdr_options.m_r_err_scale = 1.0f; |
| m_params.m_uastc_hdr_options.m_g_err_scale = 1.0f; |
| } |
| |
| const float DEFAULT_BC6H_ERROR_WEIGHT = .85f; |
| const float LOWEST_BC6H_ERROR_WEIGHT = .1f; |
| m_params.m_uastc_hdr_options.m_bc6h_err_weight = m_params.m_hdr_favor_astc ? LOWEST_BC6H_ERROR_WEIGHT : DEFAULT_BC6H_ERROR_WEIGHT; |
| |
| std::atomic<bool> any_failures; |
| any_failures = false; |
| |
| astc_hdr_block_stats enc_stats; |
| |
| struct uastc_blk_desc |
| { |
| uint32_t m_solid_flag; |
| uint32_t m_num_partitions; |
| uint32_t m_cem_index; |
| uint32_t m_weight_ise_range; |
| uint32_t m_endpoint_ise_range; |
| |
| bool operator< (const uastc_blk_desc& desc) const |
| { |
| if (this == &desc) |
| return false; |
| |
| #define COMP(XX) if (XX < desc.XX) return true; else if (XX != desc.XX) return false; |
| COMP(m_solid_flag) |
| COMP(m_num_partitions) |
| COMP(m_cem_index) |
| COMP(m_weight_ise_range) |
| COMP(m_endpoint_ise_range) |
| #undef COMP |
| |
| return false; |
| } |
| |
| bool operator== (const uastc_blk_desc& desc) const |
| { |
| if (this == &desc) |
| return true; |
| if ((*this < desc) || (desc < *this)) |
| return false; |
| return true; |
| } |
| |
| bool operator!= (const uastc_blk_desc& desc) const |
| { |
| return !(*this == desc); |
| } |
| }; |
| |
| struct uastc_blk_desc_stats |
| { |
| uastc_blk_desc_stats() : m_count(0) { } |
| uint32_t m_count; |
| #ifdef UASTC_HDR_DEBUG_SAVE_CATEGORIZED_BLOCKS |
| basisu::vector<basist::astc_blk> m_blks; |
| #endif |
| }; |
| |
| std::map<uastc_blk_desc, uastc_blk_desc_stats> unique_block_descs; |
| std::mutex unique_block_desc_mutex; |
| |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| { |
| gpu_image& tex = m_uastc_slice_textures[slice_index]; |
| basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| (void)slice_desc; |
| |
| const uint32_t num_blocks_x = tex.get_blocks_x(); |
| const uint32_t num_blocks_y = tex.get_blocks_y(); |
| const uint32_t total_blocks = tex.get_total_blocks(); |
| const imagef& source_image = m_slice_images_hdr[slice_index]; |
| |
| std::atomic<uint32_t> total_blocks_processed; |
| total_blocks_processed = 0; |
| |
| const uint32_t N = 256; |
| for (uint32_t block_index_iter = 0; block_index_iter < total_blocks; block_index_iter += N) |
| { |
| const uint32_t first_index = block_index_iter; |
| const uint32_t last_index = minimum<uint32_t>(total_blocks, block_index_iter + N); |
| |
| // FIXME: This sucks, but we're having a stack size related problem with std::function with emscripten. |
| #ifndef __EMSCRIPTEN__ |
| m_params.m_pJob_pool->add_job([this, first_index, last_index, num_blocks_x, num_blocks_y, total_blocks, &source_image, |
| &tex, &total_blocks_processed, &any_failures, &enc_stats, &unique_block_descs, &unique_block_desc_mutex] |
| { |
| #endif |
| BASISU_NOTE_UNUSED(num_blocks_y); |
| |
| basisu::vector<astc_hdr_pack_results> all_results; |
| all_results.reserve(256); |
| |
| for (uint32_t block_index = first_index; block_index < last_index; block_index++) |
| { |
| const uint32_t block_x = block_index % num_blocks_x; |
| const uint32_t block_y = block_index / num_blocks_x; |
| |
| vec4F block_pixels[16]; |
| |
| source_image.extract_block_clamped(&block_pixels[0], block_x * 4, block_y * 4, 4, 4); |
| |
| basist::astc_blk& dest_block = *(basist::astc_blk*)tex.get_block_ptr(block_x, block_y); |
| |
| float rgb_pixels[16 * 3]; |
| basist::half_float rgb_pixels_half[16 * 3]; |
| for (uint32_t i = 0; i < 16; i++) |
| { |
| rgb_pixels[i * 3 + 0] = block_pixels[i][0]; |
| rgb_pixels_half[i * 3 + 0] = float_to_half_non_neg_no_nan_inf(block_pixels[i][0]); |
| |
| rgb_pixels[i * 3 + 1] = block_pixels[i][1]; |
| rgb_pixels_half[i * 3 + 1] = float_to_half_non_neg_no_nan_inf(block_pixels[i][1]); |
| |
| rgb_pixels[i * 3 + 2] = block_pixels[i][2]; |
| rgb_pixels_half[i * 3 + 2] = float_to_half_non_neg_no_nan_inf(block_pixels[i][2]); |
| } |
| |
| bool status = astc_hdr_enc_block(&rgb_pixels[0], m_params.m_uastc_hdr_options, all_results); |
| if (!status) |
| { |
| any_failures = true; |
| continue; |
| } |
| |
| double best_err = 1e+30f; |
| int best_result_index = -1; |
| |
| const double bc6h_err_weight = m_params.m_uastc_hdr_options.m_bc6h_err_weight; |
| const double astc_err_weight = (1.0f - bc6h_err_weight); |
| |
| for (uint32_t i = 0; i < all_results.size(); i++) |
| { |
| basist::half_float unpacked_bc6h_block[4 * 4 * 3]; |
| unpack_bc6h(&all_results[i].m_bc6h_block, unpacked_bc6h_block, false); |
| |
| all_results[i].m_bc6h_block_error = compute_block_error(rgb_pixels_half, unpacked_bc6h_block, m_params.m_uastc_hdr_options); |
| |
| double overall_err = (all_results[i].m_bc6h_block_error * bc6h_err_weight) + (all_results[i].m_best_block_error * astc_err_weight); |
| |
| if ((!i) || (overall_err < best_err)) |
| { |
| best_err = overall_err; |
| best_result_index = i; |
| } |
| } |
| |
| const astc_hdr_pack_results& best_results = all_results[best_result_index]; |
| |
| astc_hdr_pack_results_to_block(dest_block, best_results); |
| |
| // Verify that this block is valid UASTC HDR and we can successfully transcode it to BC6H. |
| // (Well, except in fastest mode.) |
| if (m_params.m_uastc_hdr_options.m_level > 0) |
| { |
| basist::bc6h_block transcoded_bc6h_blk; |
| bool transcode_results = astc_hdr_transcode_to_bc6h(dest_block, transcoded_bc6h_blk); |
| assert(transcode_results); |
| if ((!transcode_results) && (!any_failures)) |
| { |
| error_printf("basis_compressor::encode_slices_to_uastc_hdr: UASTC HDR block transcode check failed!\n"); |
| |
| any_failures = true; |
| continue; |
| } |
| } |
| |
| if (m_params.m_debug) |
| { |
| // enc_stats has its own mutex |
| enc_stats.update(best_results); |
| |
| uastc_blk_desc blk_desc; |
| clear_obj(blk_desc); |
| |
| blk_desc.m_solid_flag = best_results.m_is_solid; |
| if (!blk_desc.m_solid_flag) |
| { |
| blk_desc.m_num_partitions = best_results.m_best_blk.m_num_partitions; |
| blk_desc.m_cem_index = best_results.m_best_blk.m_color_endpoint_modes[0]; |
| blk_desc.m_weight_ise_range = best_results.m_best_blk.m_weight_ise_range; |
| blk_desc.m_endpoint_ise_range = best_results.m_best_blk.m_endpoint_ise_range; |
| } |
| |
| { |
| std::lock_guard<std::mutex> lck(unique_block_desc_mutex); |
| |
| auto res = unique_block_descs.insert(std::make_pair(blk_desc, uastc_blk_desc_stats())); |
| |
| (res.first)->second.m_count++; |
| #ifdef UASTC_HDR_DEBUG_SAVE_CATEGORIZED_BLOCKS |
| (res.first)->second.m_blks.push_back(dest_block); |
| #endif |
| } |
| } |
| |
| total_blocks_processed++; |
| |
| uint32_t val = total_blocks_processed; |
| if (((val & 1023) == 1023) && m_params.m_status_output) |
| { |
| debug_printf("basis_compressor::encode_slices_to_uastc_hdr: %3.1f%% done\n", static_cast<float>(val) * 100.0f / total_blocks); |
| } |
| } |
| |
| #ifndef __EMSCRIPTEN__ |
| }); |
| #endif |
| |
| } // block_index_iter |
| |
| #ifndef __EMSCRIPTEN__ |
| m_params.m_pJob_pool->wait_for_all(); |
| #endif |
| |
| if (any_failures) |
| return cECFailedEncodeUASTC; |
| |
| m_uastc_backend_output.m_slice_image_data[slice_index].resize(tex.get_size_in_bytes()); |
| memcpy(&m_uastc_backend_output.m_slice_image_data[slice_index][0], tex.get_ptr(), tex.get_size_in_bytes()); |
| |
| m_uastc_backend_output.m_slice_image_crcs[slice_index] = basist::crc16(tex.get_ptr(), tex.get_size_in_bytes(), 0); |
| |
| } // slice_index |
| |
| debug_printf("basis_compressor::encode_slices_to_uastc_hdr: Total time: %3.3f secs\n", tm.get_elapsed_secs()); |
| |
| if (m_params.m_debug) |
| { |
| debug_printf("\n----- Total unique UASTC block descs: %u\n", (uint32_t)unique_block_descs.size()); |
| |
| uint32_t c = 0; |
| for (auto it = unique_block_descs.begin(); it != unique_block_descs.end(); ++it) |
| { |
| debug_printf("%u. Total uses: %u %3.2f%%, solid color: %u\n", c, it->second.m_count, |
| ((float)it->second.m_count * 100.0f) / enc_stats.m_total_blocks, it->first.m_solid_flag); |
| |
| if (!it->first.m_solid_flag) |
| { |
| debug_printf(" Num partitions: %u\n", it->first.m_num_partitions); |
| debug_printf(" CEM index: %u\n", it->first.m_cem_index); |
| debug_printf(" Weight ISE range: %u (%u levels)\n", it->first.m_weight_ise_range, astc_helpers::get_ise_levels(it->first.m_weight_ise_range)); |
| debug_printf(" Endpoint ISE range: %u (%u levels)\n", it->first.m_endpoint_ise_range, astc_helpers::get_ise_levels(it->first.m_endpoint_ise_range)); |
| } |
| |
| #ifdef UASTC_HDR_DEBUG_SAVE_CATEGORIZED_BLOCKS |
| debug_printf(" -- UASTC HDR block bytes:\n"); |
| for (uint32_t j = 0; j < minimum<uint32_t>(4, it->second.m_blks.size()); j++) |
| { |
| basist::astc_blk& blk = it->second.m_blks[j]; |
| |
| debug_printf(" - UASTC HDR: { "); |
| for (uint32_t k = 0; k < 16; k++) |
| debug_printf("%u%s", ((const uint8_t*)&blk)[k], (k != 15) ? ", " : ""); |
| debug_printf(" }\n"); |
| |
| basist::bc6h_block bc6h_blk; |
| bool res = astc_hdr_transcode_to_bc6h(blk, bc6h_blk); |
| assert(res); |
| if (!res) |
| { |
| error_printf("astc_hdr_transcode_to_bc6h() failed!\n"); |
| return cECFailedEncodeUASTC; |
| } |
| |
| debug_printf(" - BC6H: { "); |
| for (uint32_t k = 0; k < 16; k++) |
| debug_printf("%u%s", ((const uint8_t*)&bc6h_blk)[k], (k != 15) ? ", " : ""); |
| debug_printf(" }\n"); |
| } |
| #endif |
| |
| c++; |
| } |
| printf("\n"); |
| |
| enc_stats.print(); |
| } |
| |
| return cECSuccess; |
| } |
| |
| basis_compressor::error_code basis_compressor::encode_slices_to_uastc() |
| { |
| debug_printf("basis_compressor::encode_slices_to_uastc\n"); |
| |
| m_uastc_slice_textures.resize(m_slice_descs.size()); |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| m_uastc_slice_textures[slice_index].init(texture_format::cUASTC4x4, m_slice_descs[slice_index].m_orig_width, m_slice_descs[slice_index].m_orig_height); |
| |
| m_uastc_backend_output.m_tex_format = basist::basis_tex_format::cUASTC4x4; |
| m_uastc_backend_output.m_etc1s = false; |
| m_uastc_backend_output.m_slice_desc = m_slice_descs; |
| m_uastc_backend_output.m_slice_image_data.resize(m_slice_descs.size()); |
| m_uastc_backend_output.m_slice_image_crcs.resize(m_slice_descs.size()); |
| |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| { |
| gpu_image& tex = m_uastc_slice_textures[slice_index]; |
| basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| (void)slice_desc; |
| |
| const uint32_t num_blocks_x = tex.get_blocks_x(); |
| const uint32_t num_blocks_y = tex.get_blocks_y(); |
| const uint32_t total_blocks = tex.get_total_blocks(); |
| const image& source_image = m_slice_images[slice_index]; |
| |
| std::atomic<uint32_t> total_blocks_processed; |
| total_blocks_processed = 0; |
| |
| const uint32_t N = 256; |
| for (uint32_t block_index_iter = 0; block_index_iter < total_blocks; block_index_iter += N) |
| { |
| const uint32_t first_index = block_index_iter; |
| const uint32_t last_index = minimum<uint32_t>(total_blocks, block_index_iter + N); |
| |
| // FIXME: This sucks, but we're having a stack size related problem with std::function with emscripten. |
| #ifndef __EMSCRIPTEN__ |
| m_params.m_pJob_pool->add_job([this, first_index, last_index, num_blocks_x, num_blocks_y, total_blocks, &source_image, &tex, &total_blocks_processed] |
| { |
| #endif |
| BASISU_NOTE_UNUSED(num_blocks_y); |
| |
| uint32_t uastc_flags = m_params.m_pack_uastc_flags; |
| if ((m_params.m_rdo_uastc) && (m_params.m_rdo_uastc_favor_simpler_modes_in_rdo_mode)) |
| uastc_flags |= cPackUASTCFavorSimplerModes; |
| |
| for (uint32_t block_index = first_index; block_index < last_index; block_index++) |
| { |
| const uint32_t block_x = block_index % num_blocks_x; |
| const uint32_t block_y = block_index / num_blocks_x; |
| |
| color_rgba block_pixels[4][4]; |
| |
| source_image.extract_block_clamped((color_rgba*)block_pixels, block_x * 4, block_y * 4, 4, 4); |
| |
| basist::uastc_block& dest_block = *(basist::uastc_block*)tex.get_block_ptr(block_x, block_y); |
| |
| encode_uastc(&block_pixels[0][0].r, dest_block, uastc_flags); |
| |
| total_blocks_processed++; |
| |
| uint32_t val = total_blocks_processed; |
| if (((val & 16383) == 16383) && m_params.m_status_output) |
| { |
| debug_printf("basis_compressor::encode_slices_to_uastc: %3.1f%% done\n", static_cast<float>(val) * 100.0f / total_blocks); |
| } |
| |
| } |
| |
| #ifndef __EMSCRIPTEN__ |
| }); |
| #endif |
| |
| } // block_index_iter |
| |
| #ifndef __EMSCRIPTEN__ |
| m_params.m_pJob_pool->wait_for_all(); |
| #endif |
| |
| if (m_params.m_rdo_uastc) |
| { |
| uastc_rdo_params rdo_params; |
| rdo_params.m_lambda = m_params.m_rdo_uastc_quality_scalar; |
| rdo_params.m_max_allowed_rms_increase_ratio = m_params.m_rdo_uastc_max_allowed_rms_increase_ratio; |
| rdo_params.m_skip_block_rms_thresh = m_params.m_rdo_uastc_skip_block_rms_thresh; |
| rdo_params.m_lz_dict_size = m_params.m_rdo_uastc_dict_size; |
| rdo_params.m_smooth_block_max_error_scale = m_params.m_rdo_uastc_max_smooth_block_error_scale; |
| rdo_params.m_max_smooth_block_std_dev = m_params.m_rdo_uastc_smooth_block_max_std_dev; |
| |
| bool status = uastc_rdo(tex.get_total_blocks(), (basist::uastc_block*)tex.get_ptr(), |
| (const color_rgba *)m_source_blocks[slice_desc.m_first_block_index].m_pixels, rdo_params, m_params.m_pack_uastc_flags, m_params.m_rdo_uastc_multithreading ? m_params.m_pJob_pool : nullptr, |
| (m_params.m_rdo_uastc_multithreading && m_params.m_pJob_pool) ? basisu::minimum<uint32_t>(4, (uint32_t)m_params.m_pJob_pool->get_total_threads()) : 0); |
| if (!status) |
| { |
| return cECFailedUASTCRDOPostProcess; |
| } |
| } |
| |
| m_uastc_backend_output.m_slice_image_data[slice_index].resize(tex.get_size_in_bytes()); |
| memcpy(&m_uastc_backend_output.m_slice_image_data[slice_index][0], tex.get_ptr(), tex.get_size_in_bytes()); |
| |
| m_uastc_backend_output.m_slice_image_crcs[slice_index] = basist::crc16(tex.get_ptr(), tex.get_size_in_bytes(), 0); |
| |
| } // slice_index |
| |
| return cECSuccess; |
| } |
| |
| bool basis_compressor::generate_mipmaps(const imagef& img, basisu::vector<imagef>& mips, bool has_alpha) |
| { |
| debug_printf("basis_compressor::generate_mipmaps\n"); |
| |
| interval_timer tm; |
| tm.start(); |
| |
| uint32_t total_levels = 1; |
| uint32_t w = img.get_width(), h = img.get_height(); |
| while (maximum<uint32_t>(w, h) > (uint32_t)m_params.m_mip_smallest_dimension) |
| { |
| w = maximum(w >> 1U, 1U); |
| h = maximum(h >> 1U, 1U); |
| total_levels++; |
| } |
| |
| for (uint32_t level = 1; level < total_levels; level++) |
| { |
| const uint32_t level_width = maximum<uint32_t>(1, img.get_width() >> level); |
| const uint32_t level_height = maximum<uint32_t>(1, img.get_height() >> level); |
| |
| imagef& level_img = *enlarge_vector(mips, 1); |
| level_img.resize(level_width, level_height); |
| |
| const imagef* pSource_image = &img; |
| |
| if (m_params.m_mip_fast) |
| { |
| if (level > 1) |
| pSource_image = &mips[level - 1]; |
| } |
| |
| bool status = image_resample(*pSource_image, level_img, |
| //m_params.m_mip_filter.c_str(), |
| "box", // TODO: negative lobes in the filter are causing negative colors, try Mitchell |
| m_params.m_mip_scale, m_params.m_mip_wrapping, 0, has_alpha ? 4 : 3); |
| if (!status) |
| { |
| error_printf("basis_compressor::generate_mipmaps: image_resample() failed!\n"); |
| return false; |
| } |
| |
| clean_hdr_image(level_img); |
| } |
| |
| if (m_params.m_debug) |
| debug_printf("Total mipmap generation time: %3.3f secs\n", tm.get_elapsed_secs()); |
| |
| return true; |
| } |
| |
| bool basis_compressor::generate_mipmaps(const image &img, basisu::vector<image> &mips, bool has_alpha) |
| { |
| debug_printf("basis_compressor::generate_mipmaps\n"); |
| |
| interval_timer tm; |
| tm.start(); |
| |
| uint32_t total_levels = 1; |
| uint32_t w = img.get_width(), h = img.get_height(); |
| while (maximum<uint32_t>(w, h) > (uint32_t)m_params.m_mip_smallest_dimension) |
| { |
| w = maximum(w >> 1U, 1U); |
| h = maximum(h >> 1U, 1U); |
| total_levels++; |
| } |
| |
| #if BASISU_USE_STB_IMAGE_RESIZE_FOR_MIPMAP_GEN |
| // Requires stb_image_resize |
| stbir_filter filter = STBIR_FILTER_DEFAULT; |
| if (m_params.m_mip_filter == "box") |
| filter = STBIR_FILTER_BOX; |
| else if (m_params.m_mip_filter == "triangle") |
| filter = STBIR_FILTER_TRIANGLE; |
| else if (m_params.m_mip_filter == "cubic") |
| filter = STBIR_FILTER_CUBICBSPLINE; |
| else if (m_params.m_mip_filter == "catmull") |
| filter = STBIR_FILTER_CATMULLROM; |
| else if (m_params.m_mip_filter == "mitchell") |
| filter = STBIR_FILTER_MITCHELL; |
| |
| for (uint32_t level = 1; level < total_levels; level++) |
| { |
| const uint32_t level_width = maximum<uint32_t>(1, img.get_width() >> level); |
| const uint32_t level_height = maximum<uint32_t>(1, img.get_height() >> level); |
| |
| image &level_img = *enlarge_vector(mips, 1); |
| level_img.resize(level_width, level_height); |
| |
| int result = stbir_resize_uint8_generic( |
| (const uint8_t *)img.get_ptr(), img.get_width(), img.get_height(), img.get_pitch() * sizeof(color_rgba), |
| (uint8_t *)level_img.get_ptr(), level_img.get_width(), level_img.get_height(), level_img.get_pitch() * sizeof(color_rgba), |
| has_alpha ? 4 : 3, has_alpha ? 3 : STBIR_ALPHA_CHANNEL_NONE, m_params.m_mip_premultiplied ? STBIR_FLAG_ALPHA_PREMULTIPLIED : 0, |
| m_params.m_mip_wrapping ? STBIR_EDGE_WRAP : STBIR_EDGE_CLAMP, filter, m_params.m_mip_srgb ? STBIR_COLORSPACE_SRGB : STBIR_COLORSPACE_LINEAR, |
| nullptr); |
| |
| if (result == 0) |
| { |
| error_printf("basis_compressor::generate_mipmaps: stbir_resize_uint8_generic() failed!\n"); |
| return false; |
| } |
| |
| if (m_params.m_mip_renormalize) |
| level_img.renormalize_normal_map(); |
| } |
| #else |
| for (uint32_t level = 1; level < total_levels; level++) |
| { |
| const uint32_t level_width = maximum<uint32_t>(1, img.get_width() >> level); |
| const uint32_t level_height = maximum<uint32_t>(1, img.get_height() >> level); |
| |
| image& level_img = *enlarge_vector(mips, 1); |
| level_img.resize(level_width, level_height); |
| |
| const image* pSource_image = &img; |
| |
| if (m_params.m_mip_fast) |
| { |
| if (level > 1) |
| pSource_image = &mips[level - 1]; |
| } |
| |
| bool status = image_resample(*pSource_image, level_img, m_params.m_mip_srgb, m_params.m_mip_filter.c_str(), m_params.m_mip_scale, m_params.m_mip_wrapping, 0, has_alpha ? 4 : 3); |
| if (!status) |
| { |
| error_printf("basis_compressor::generate_mipmaps: image_resample() failed!\n"); |
| return false; |
| } |
| |
| if (m_params.m_mip_renormalize) |
| level_img.renormalize_normal_map(); |
| } |
| #endif |
| |
| if (m_params.m_debug) |
| debug_printf("Total mipmap generation time: %3.3f secs\n", tm.get_elapsed_secs()); |
| |
| return true; |
| } |
| |
| void basis_compressor::clean_hdr_image(imagef& src_img) |
| { |
| const uint32_t width = src_img.get_width(); |
| const uint32_t height = src_img.get_height(); |
| |
| float max_used_val = 0.0f; |
| for (uint32_t y = 0; y < height; y++) |
| { |
| for (uint32_t x = 0; x < width; x++) |
| { |
| vec4F& c = src_img(x, y); |
| for (uint32_t i = 0; i < 3; i++) |
| max_used_val = maximum(max_used_val, c[i]); |
| } |
| } |
| |
| double hdr_image_scale = 1.0f; |
| if (max_used_val > basist::ASTC_HDR_MAX_VAL) |
| { |
| hdr_image_scale = max_used_val / basist::ASTC_HDR_MAX_VAL; |
| |
| const double inv_hdr_image_scale = basist::ASTC_HDR_MAX_VAL / max_used_val; |
| |
| for (uint32_t y = 0; y < src_img.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < src_img.get_width(); x++) |
| { |
| vec4F& c = src_img(x, y); |
| |
| for (uint32_t i = 0; i < 3; i++) |
| c[i] = (float)minimum<double>(c[i] * inv_hdr_image_scale, basist::ASTC_HDR_MAX_VAL); |
| } |
| } |
| |
| printf("Warning: The input HDR image's maximum used float value was %f, which is too high to encode as ASTC HDR. The image's components have been linearly scaled so the maximum used value is %f, by multiplying by %f.\n", |
| max_used_val, basist::ASTC_HDR_MAX_VAL, inv_hdr_image_scale); |
| |
| printf("The decoded ASTC HDR texture will have to be scaled up by %f.\n", hdr_image_scale); |
| } |
| |
| // TODO: Determine a constant scale factor, apply if > MAX_HALF_FLOAT |
| if (!src_img.clean_astc_hdr_pixels(basist::ASTC_HDR_MAX_VAL)) |
| printf("Warning: clean_astc_hdr_pixels() had to modify the input image to encode to ASTC HDR - see previous warning(s).\n"); |
| |
| float lowest_nonzero_val = 1e+30f; |
| float lowest_val = 1e+30f; |
| float highest_val = -1e+30f; |
| |
| for (uint32_t y = 0; y < src_img.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < src_img.get_width(); x++) |
| { |
| const vec4F& c = src_img(x, y); |
| |
| for (uint32_t i = 0; i < 3; i++) |
| { |
| lowest_val = basisu::minimum(lowest_val, c[i]); |
| |
| if (c[i] != 0.0f) |
| lowest_nonzero_val = basisu::minimum(lowest_nonzero_val, c[i]); |
| |
| highest_val = basisu::maximum(highest_val, c[i]); |
| } |
| } |
| } |
| |
| debug_printf("Lowest image value: %e, lowest non-zero value: %e, highest value: %e, dynamic range: %e\n", lowest_val, lowest_nonzero_val, highest_val, highest_val / lowest_nonzero_val); |
| } |
| |
| bool basis_compressor::read_dds_source_images() |
| { |
| debug_printf("basis_compressor::read_dds_source_images\n"); |
| |
| // Nothing to do if the caller doesn't want us reading source images. |
| if ((!m_params.m_read_source_images) || (!m_params.m_source_filenames.size())) |
| return true; |
| |
| // Just bail of the caller has specified their own source images. |
| if (m_params.m_source_images.size() || m_params.m_source_images_hdr.size()) |
| return true; |
| |
| if (m_params.m_source_mipmap_images.size() || m_params.m_source_mipmap_images_hdr.size()) |
| return true; |
| |
| // See if any input filenames are .DDS |
| bool any_dds = false, all_dds = true; |
| for (uint32_t i = 0; i < m_params.m_source_filenames.size(); i++) |
| { |
| std::string ext(string_get_extension(m_params.m_source_filenames[i])); |
| if (strcasecmp(ext.c_str(), "dds") == 0) |
| any_dds = true; |
| else |
| all_dds = false; |
| } |
| |
| // Bail if no .DDS files specified. |
| if (!any_dds) |
| return true; |
| |
| // If any input is .DDS they all must be .DDS, for simplicity. |
| if (!all_dds) |
| { |
| error_printf("If any filename is DDS, all filenames must be DDS.\n"); |
| return false; |
| } |
| |
| // Can't jam in alpha channel images if any .DDS files specified. |
| if (m_params.m_source_alpha_filenames.size()) |
| { |
| error_printf("Source alpha filenames are not supported in DDS mode.\n"); |
| return false; |
| } |
| |
| bool any_mipmaps = false; |
| |
| // Read each .DDS texture file |
| for (uint32_t i = 0; i < m_params.m_source_filenames.size(); i++) |
| { |
| basisu::vector<image> ldr_mips; |
| basisu::vector<imagef> hdr_mips; |
| bool status = read_uncompressed_dds_file(m_params.m_source_filenames[i].c_str(), ldr_mips, hdr_mips); |
| if (!status) |
| return false; |
| |
| assert(ldr_mips.size() || hdr_mips.size()); |
| |
| if (m_params.m_status_output) |
| { |
| printf("Read DDS file \"%s\", %s, %ux%u, %u mipmap levels\n", |
| m_params.m_source_filenames[i].c_str(), |
| ldr_mips.size() ? "LDR" : "HDR", |
| ldr_mips.size() ? ldr_mips[0].get_width() : hdr_mips[0].get_width(), |
| ldr_mips.size() ? ldr_mips[0].get_height() : hdr_mips[0].get_height(), |
| ldr_mips.size() ? ldr_mips.size() : hdr_mips.size()); |
| } |
| |
| if (ldr_mips.size()) |
| { |
| if (m_params.m_source_images_hdr.size()) |
| { |
| error_printf("All DDS files must be of the same type (all LDR, or all HDR)\n"); |
| return false; |
| } |
| |
| m_params.m_source_images.push_back(ldr_mips[0]); |
| m_params.m_source_mipmap_images.resize(m_params.m_source_mipmap_images.size() + 1); |
| |
| if (ldr_mips.size() > 1) |
| { |
| ldr_mips.erase(0U); |
| |
| m_params.m_source_mipmap_images.back().swap(ldr_mips); |
| |
| any_mipmaps = true; |
| } |
| } |
| else |
| { |
| if (m_params.m_source_images.size()) |
| { |
| error_printf("All DDS files must be of the same type (all LDR, or all HDR)\n"); |
| return false; |
| } |
| |
| m_params.m_source_images_hdr.push_back(hdr_mips[0]); |
| m_params.m_source_mipmap_images_hdr.resize(m_params.m_source_mipmap_images_hdr.size() + 1); |
| |
| if (hdr_mips.size() > 1) |
| { |
| hdr_mips.erase(0U); |
| |
| m_params.m_source_mipmap_images_hdr.back().swap(hdr_mips); |
| |
| any_mipmaps = true; |
| } |
| |
| m_params.m_hdr = true; |
| m_params.m_uastc = true; |
| } |
| } |
| |
| m_params.m_read_source_images = false; |
| m_params.m_source_filenames.clear(); |
| m_params.m_source_alpha_filenames.clear(); |
| |
| if (!any_mipmaps) |
| { |
| m_params.m_source_mipmap_images.clear(); |
| m_params.m_source_mipmap_images_hdr.clear(); |
| } |
| |
| if ((m_params.m_hdr) && (!m_params.m_source_images_hdr.size())) |
| { |
| error_printf("HDR mode enabled, but only LDR .DDS files were loaded. HDR mode requires half or float (HDR) .DDS inputs.\n"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::read_source_images() |
| { |
| debug_printf("basis_compressor::read_source_images\n"); |
| |
| const uint32_t total_source_files = m_params.m_read_source_images ? (uint32_t)m_params.m_source_filenames.size() : |
| (m_params.m_hdr ? (uint32_t)m_params.m_source_images_hdr.size() : (uint32_t)m_params.m_source_images.size()); |
| |
| if (!total_source_files) |
| { |
| debug_printf("basis_compressor::read_source_images: No source images to process\n"); |
| |
| return false; |
| } |
| |
| m_stats.resize(0); |
| m_slice_descs.resize(0); |
| m_slice_images.resize(0); |
| m_slice_images_hdr.resize(0); |
| |
| m_total_blocks = 0; |
| uint32_t total_macroblocks = 0; |
| |
| m_any_source_image_has_alpha = false; |
| |
| basisu::vector<image> source_images; |
| basisu::vector<imagef> source_images_hdr; |
| |
| basisu::vector<std::string> source_filenames; |
| |
| // TODO: Note HDR images don't support alpha here, currently. |
| |
| // First load all source images, and determine if any have an alpha channel. |
| for (uint32_t source_file_index = 0; source_file_index < total_source_files; source_file_index++) |
| { |
| const char* pSource_filename = ""; |
| |
| image file_image; |
| imagef file_image_hdr; |
| |
| if (m_params.m_read_source_images) |
| { |
| pSource_filename = m_params.m_source_filenames[source_file_index].c_str(); |
| |
| // Load the source image |
| if (m_params.m_hdr) |
| { |
| if (!load_image_hdr(pSource_filename, file_image_hdr, m_params.m_hdr_ldr_srgb_to_linear_conversion)) |
| { |
| error_printf("Failed reading source image: %s\n", pSource_filename); |
| return false; |
| } |
| |
| // For now, just slam alpha to 1.0f. UASTC HDR doesn't support alpha yet. |
| for (uint32_t y = 0; y < file_image_hdr.get_height(); y++) |
| for (uint32_t x = 0; x < file_image_hdr.get_width(); x++) |
| file_image_hdr(x, y)[3] = 1.0f; |
| } |
| else |
| { |
| if (!load_image(pSource_filename, file_image)) |
| { |
| error_printf("Failed reading source image: %s\n", pSource_filename); |
| return false; |
| } |
| } |
| |
| const uint32_t width = m_params.m_hdr ? file_image_hdr.get_width() : file_image.get_width(); |
| const uint32_t height = m_params.m_hdr ? file_image_hdr.get_height() : file_image.get_height(); |
| |
| if (m_params.m_status_output) |
| { |
| printf("Read source image \"%s\", %ux%u\n", pSource_filename, width, height); |
| } |
| |
| if (m_params.m_hdr) |
| { |
| clean_hdr_image(file_image_hdr); |
| } |
| else |
| { |
| // Optionally load another image and put a grayscale version of it into the alpha channel. |
| if ((source_file_index < m_params.m_source_alpha_filenames.size()) && (m_params.m_source_alpha_filenames[source_file_index].size())) |
| { |
| const char* pSource_alpha_image = m_params.m_source_alpha_filenames[source_file_index].c_str(); |
| |
| image alpha_data; |
| |
| if (!load_image(pSource_alpha_image, alpha_data)) |
| { |
| error_printf("Failed reading source image: %s\n", pSource_alpha_image); |
| return false; |
| } |
| |
| printf("Read source alpha image \"%s\", %ux%u\n", pSource_alpha_image, alpha_data.get_width(), alpha_data.get_height()); |
| |
| alpha_data.crop(width, height); |
| |
| for (uint32_t y = 0; y < height; y++) |
| for (uint32_t x = 0; x < width; x++) |
| file_image(x, y).a = (uint8_t)alpha_data(x, y).get_709_luma(); |
| } |
| } |
| } |
| else |
| { |
| if (m_params.m_hdr) |
| { |
| file_image_hdr = m_params.m_source_images_hdr[source_file_index]; |
| clean_hdr_image(file_image_hdr); |
| } |
| else |
| { |
| file_image = m_params.m_source_images[source_file_index]; |
| } |
| } |
| |
| if (!m_params.m_hdr) |
| { |
| if (m_params.m_renormalize) |
| file_image.renormalize_normal_map(); |
| } |
| |
| bool alpha_swizzled = false; |
| |
| if (m_params.m_swizzle[0] != 0 || |
| m_params.m_swizzle[1] != 1 || |
| m_params.m_swizzle[2] != 2 || |
| m_params.m_swizzle[3] != 3) |
| { |
| if (!m_params.m_hdr) |
| { |
| // Used for XY normal maps in RG - puts X in color, Y in alpha |
| for (uint32_t y = 0; y < file_image.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < file_image.get_width(); x++) |
| { |
| const color_rgba& c = file_image(x, y); |
| file_image(x, y).set_noclamp_rgba(c[m_params.m_swizzle[0]], c[m_params.m_swizzle[1]], c[m_params.m_swizzle[2]], c[m_params.m_swizzle[3]]); |
| } |
| } |
| |
| alpha_swizzled = (m_params.m_swizzle[3] != 3); |
| } |
| else |
| { |
| // Used for XY normal maps in RG - puts X in color, Y in alpha |
| for (uint32_t y = 0; y < file_image_hdr.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < file_image_hdr.get_width(); x++) |
| { |
| const vec4F& c = file_image_hdr(x, y); |
| |
| // For now, alpha is always 1.0f in UASTC HDR. |
| file_image_hdr(x, y).set(c[m_params.m_swizzle[0]], c[m_params.m_swizzle[1]], c[m_params.m_swizzle[2]], 1.0f); // c[m_params.m_swizzle[3]]); |
| } |
| } |
| } |
| } |
| |
| bool has_alpha = false; |
| |
| if (!m_params.m_hdr) |
| { |
| if (m_params.m_force_alpha || alpha_swizzled) |
| has_alpha = true; |
| else if (!m_params.m_check_for_alpha) |
| file_image.set_alpha(255); |
| else if (file_image.has_alpha()) |
| has_alpha = true; |
| |
| if (has_alpha) |
| m_any_source_image_has_alpha = true; |
| } |
| |
| { |
| const uint32_t width = m_params.m_hdr ? file_image_hdr.get_width() : file_image.get_width(); |
| const uint32_t height = m_params.m_hdr ? file_image_hdr.get_height() : file_image.get_height(); |
| |
| debug_printf("Source image index %u filename %s %ux%u has alpha: %u\n", source_file_index, pSource_filename, width, height, has_alpha); |
| } |
| |
| if (m_params.m_y_flip) |
| { |
| if (m_params.m_hdr) |
| file_image_hdr.flip_y(); |
| else |
| file_image.flip_y(); |
| } |
| |
| #if DEBUG_EXTRACT_SINGLE_BLOCK |
| const uint32_t block_x = 0; |
| const uint32_t block_y = 0; |
| |
| if (m_params.m_hdr) |
| { |
| imagef block_image(4, 4); |
| block_image_hdr.blit(block_x * 4, block_y * 4, 4, 4, 0, 0, file_image_hdr, 0); |
| file_image_hdr = block_image; |
| } |
| else |
| { |
| image block_image(4, 4); |
| block_image.blit(block_x * 4, block_y * 4, 4, 4, 0, 0, file_image, 0); |
| file_image = block_image; |
| } |
| #endif |
| |
| #if DEBUG_CROP_TEXTURE_TO_64x64 |
| if (m_params.m_hdr) |
| file_image_hdr.resize(64, 64); |
| else |
| file_image.resize(64, 64); |
| #endif |
| |
| if ((m_params.m_resample_width > 0) && (m_params.m_resample_height > 0)) |
| { |
| int new_width = basisu::minimum<int>(m_params.m_resample_width, BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| int new_height = basisu::minimum<int>(m_params.m_resample_height, BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| |
| debug_printf("Resampling to %ix%i\n", new_width, new_height); |
| |
| // TODO: A box filter - kaiser looks too sharp on video. Let the caller control this. |
| if (m_params.m_hdr) |
| { |
| imagef temp_img(new_width, new_height); |
| image_resample(file_image_hdr, temp_img, "box"); // "kaiser"); |
| clean_hdr_image(temp_img); |
| temp_img.swap(file_image_hdr); |
| } |
| else |
| { |
| image temp_img(new_width, new_height); |
| image_resample(file_image, temp_img, m_params.m_perceptual, "box"); // "kaiser"); |
| temp_img.swap(file_image); |
| } |
| } |
| else if (m_params.m_resample_factor > 0.0f) |
| { |
| // TODO: A box filter - kaiser looks too sharp on video. Let the caller control this. |
| if (m_params.m_hdr) |
| { |
| int new_width = basisu::minimum<int>(basisu::maximum(1, (int)ceilf(file_image_hdr.get_width() * m_params.m_resample_factor)), BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| int new_height = basisu::minimum<int>(basisu::maximum(1, (int)ceilf(file_image_hdr.get_height() * m_params.m_resample_factor)), BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| |
| debug_printf("Resampling to %ix%i\n", new_width, new_height); |
| |
| imagef temp_img(new_width, new_height); |
| image_resample(file_image_hdr, temp_img, "box"); // "kaiser"); |
| clean_hdr_image(temp_img); |
| temp_img.swap(file_image_hdr); |
| } |
| else |
| { |
| int new_width = basisu::minimum<int>(basisu::maximum(1, (int)ceilf(file_image.get_width() * m_params.m_resample_factor)), BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| int new_height = basisu::minimum<int>(basisu::maximum(1, (int)ceilf(file_image.get_height() * m_params.m_resample_factor)), BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION); |
| |
| debug_printf("Resampling to %ix%i\n", new_width, new_height); |
| |
| image temp_img(new_width, new_height); |
| image_resample(file_image, temp_img, m_params.m_perceptual, "box"); // "kaiser"); |
| temp_img.swap(file_image); |
| } |
| } |
| |
| const uint32_t width = m_params.m_hdr ? file_image_hdr.get_width() : file_image.get_width(); |
| const uint32_t height = m_params.m_hdr ? file_image_hdr.get_height() : file_image.get_height(); |
| |
| if ((!width) || (!height)) |
| { |
| error_printf("basis_compressor::read_source_images: Source image has a zero width and/or height!\n"); |
| return false; |
| } |
| |
| if ((width > BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION) || (height > BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION)) |
| { |
| error_printf("basis_compressor::read_source_images: Source image \"%s\" is too large!\n", pSource_filename); |
| return false; |
| } |
| |
| if (!m_params.m_hdr) |
| source_images.enlarge(1)->swap(file_image); |
| else |
| source_images_hdr.enlarge(1)->swap(file_image_hdr); |
| |
| source_filenames.push_back(pSource_filename); |
| } |
| |
| // Check if the caller has generated their own mipmaps. |
| if (m_params.m_hdr) |
| { |
| if (m_params.m_source_mipmap_images_hdr.size()) |
| { |
| // Make sure they've passed us enough mipmap chains. |
| if ((m_params.m_source_images_hdr.size() != m_params.m_source_mipmap_images_hdr.size()) || (total_source_files != m_params.m_source_images_hdr.size())) |
| { |
| error_printf("basis_compressor::read_source_images(): m_params.m_source_mipmap_images_hdr.size() must equal m_params.m_source_images_hdr.size()!\n"); |
| return false; |
| } |
| } |
| } |
| else |
| { |
| if (m_params.m_source_mipmap_images.size()) |
| { |
| // Make sure they've passed us enough mipmap chains. |
| if ((m_params.m_source_images.size() != m_params.m_source_mipmap_images.size()) || (total_source_files != m_params.m_source_images.size())) |
| { |
| error_printf("basis_compressor::read_source_images(): m_params.m_source_mipmap_images.size() must equal m_params.m_source_images.size()!\n"); |
| return false; |
| } |
| |
| // Check if any of the user-supplied mipmap levels has alpha. |
| if (!m_any_source_image_has_alpha) |
| { |
| for (uint32_t source_file_index = 0; source_file_index < total_source_files; source_file_index++) |
| { |
| for (uint32_t mip_index = 0; mip_index < m_params.m_source_mipmap_images[source_file_index].size(); mip_index++) |
| { |
| const image& mip_img = m_params.m_source_mipmap_images[source_file_index][mip_index]; |
| |
| // Be sure to take into account any swizzling which will be applied. |
| if (mip_img.has_alpha(m_params.m_swizzle[3])) |
| { |
| m_any_source_image_has_alpha = true; |
| break; |
| } |
| } |
| |
| if (m_any_source_image_has_alpha) |
| break; |
| } |
| } |
| } |
| } |
| |
| debug_printf("Any source image has alpha: %u\n", m_any_source_image_has_alpha); |
| |
| // Now, for each source image, create the slices corresponding to that image. |
| for (uint32_t source_file_index = 0; source_file_index < total_source_files; source_file_index++) |
| { |
| const std::string &source_filename = source_filenames[source_file_index]; |
| |
| basisu::vector<image> slices; |
| basisu::vector<imagef> slices_hdr; |
| |
| slices.reserve(32); |
| slices_hdr.reserve(32); |
| |
| // The first (largest) mipmap level. |
| image *pFile_image = source_images.size() ? &source_images[source_file_index] : nullptr; |
| imagef *pFile_image_hdr = source_images_hdr.size() ? &source_images_hdr[source_file_index] : nullptr; |
| |
| // Reserve a slot for mip0. |
| if (m_params.m_hdr) |
| slices_hdr.resize(1); |
| else |
| slices.resize(1); |
| |
| if ((!m_params.m_hdr) && (m_params.m_source_mipmap_images.size())) |
| { |
| // User-provided mipmaps for each layer or image in the texture array. |
| for (uint32_t mip_index = 0; mip_index < m_params.m_source_mipmap_images[source_file_index].size(); mip_index++) |
| { |
| image& mip_img = m_params.m_source_mipmap_images[source_file_index][mip_index]; |
| |
| if ((m_params.m_swizzle[0] != 0) || |
| (m_params.m_swizzle[1] != 1) || |
| (m_params.m_swizzle[2] != 2) || |
| (m_params.m_swizzle[3] != 3)) |
| { |
| // Used for XY normal maps in RG - puts X in color, Y in alpha |
| for (uint32_t y = 0; y < mip_img.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < mip_img.get_width(); x++) |
| { |
| const color_rgba& c = mip_img(x, y); |
| mip_img(x, y).set_noclamp_rgba(c[m_params.m_swizzle[0]], c[m_params.m_swizzle[1]], c[m_params.m_swizzle[2]], c[m_params.m_swizzle[3]]); |
| } |
| } |
| } |
| |
| slices.push_back(mip_img); |
| } |
| } |
| else if ((m_params.m_hdr) && (m_params.m_source_mipmap_images_hdr.size())) |
| { |
| // User-provided mipmaps for each layer or image in the texture array. |
| for (uint32_t mip_index = 0; mip_index < m_params.m_source_mipmap_images_hdr[source_file_index].size(); mip_index++) |
| { |
| imagef& mip_img = m_params.m_source_mipmap_images_hdr[source_file_index][mip_index]; |
| |
| if ((m_params.m_swizzle[0] != 0) || |
| (m_params.m_swizzle[1] != 1) || |
| (m_params.m_swizzle[2] != 2) || |
| (m_params.m_swizzle[3] != 3)) |
| { |
| // Used for XY normal maps in RG - puts X in color, Y in alpha |
| for (uint32_t y = 0; y < mip_img.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < mip_img.get_width(); x++) |
| { |
| const vec4F& c = mip_img(x, y); |
| |
| // For now, HDR alpha is always 1.0f. |
| mip_img(x, y).set(c[m_params.m_swizzle[0]], c[m_params.m_swizzle[1]], c[m_params.m_swizzle[2]], 1.0f); // c[m_params.m_swizzle[3]]); |
| } |
| } |
| } |
| |
| clean_hdr_image(mip_img); |
| |
| slices_hdr.push_back(mip_img); |
| } |
| } |
| else if (m_params.m_mip_gen) |
| { |
| // Automatically generate mipmaps. |
| if (m_params.m_hdr) |
| { |
| if (!generate_mipmaps(*pFile_image_hdr, slices_hdr, m_any_source_image_has_alpha)) |
| return false; |
| } |
| else |
| { |
| if (!generate_mipmaps(*pFile_image, slices, m_any_source_image_has_alpha)) |
| return false; |
| } |
| } |
| |
| // Swap in the largest mipmap level here to avoid copying it, because generate_mips() will change the array. |
| // NOTE: file_image is now blank. |
| if (m_params.m_hdr) |
| slices_hdr[0].swap(*pFile_image_hdr); |
| else |
| slices[0].swap(*pFile_image); |
| |
| uint_vec mip_indices(m_params.m_hdr ? slices_hdr.size() : slices.size()); |
| for (uint32_t i = 0; i < (m_params.m_hdr ? slices_hdr.size() : slices.size()); i++) |
| mip_indices[i] = i; |
| |
| if ((!m_params.m_hdr) && (m_any_source_image_has_alpha) && (!m_params.m_uastc)) |
| { |
| // For ETC1S, if source has alpha, then even mips will have RGB, and odd mips will have alpha in RGB. |
| basisu::vector<image> alpha_slices; |
| uint_vec new_mip_indices; |
| |
| alpha_slices.reserve(slices.size() * 2); |
| |
| for (uint32_t i = 0; i < slices.size(); i++) |
| { |
| image lvl_rgb(slices[i]); |
| image lvl_a(lvl_rgb); |
| |
| for (uint32_t y = 0; y < lvl_a.get_height(); y++) |
| { |
| for (uint32_t x = 0; x < lvl_a.get_width(); x++) |
| { |
| uint8_t a = lvl_a(x, y).a; |
| lvl_a(x, y).set_noclamp_rgba(a, a, a, 255); |
| } |
| } |
| |
| lvl_rgb.set_alpha(255); |
| |
| alpha_slices.push_back(lvl_rgb); |
| new_mip_indices.push_back(i); |
| |
| alpha_slices.push_back(lvl_a); |
| new_mip_indices.push_back(i); |
| } |
| |
| slices.swap(alpha_slices); |
| mip_indices.swap(new_mip_indices); |
| } |
| |
| if (m_params.m_hdr) |
| { |
| assert(slices_hdr.size() == mip_indices.size()); |
| } |
| else |
| { |
| assert(slices.size() == mip_indices.size()); |
| } |
| |
| for (uint32_t slice_index = 0; slice_index < (m_params.m_hdr ? slices_hdr.size() : slices.size()); slice_index++) |
| { |
| image *pSlice_image = m_params.m_hdr ? nullptr : &slices[slice_index]; |
| imagef *pSlice_image_hdr = m_params.m_hdr ? &slices_hdr[slice_index] : nullptr; |
| |
| const uint32_t orig_width = m_params.m_hdr ? pSlice_image_hdr->get_width() : pSlice_image->get_width(); |
| const uint32_t orig_height = m_params.m_hdr ? pSlice_image_hdr->get_height() : pSlice_image->get_height(); |
| |
| bool is_alpha_slice = false; |
| if ((!m_params.m_hdr) && (m_any_source_image_has_alpha)) |
| { |
| if (m_params.m_uastc) |
| { |
| is_alpha_slice = pSlice_image->has_alpha(); |
| } |
| else |
| { |
| is_alpha_slice = (slice_index & 1) != 0; |
| } |
| } |
| |
| // Enlarge the source image to 4x4 block boundaries, duplicating edge pixels if necessary to avoid introducing extra colors into blocks. |
| if (m_params.m_hdr) |
| pSlice_image_hdr->crop_dup_borders(pSlice_image_hdr->get_block_width(4) * 4, pSlice_image_hdr->get_block_height(4) * 4); |
| else |
| pSlice_image->crop_dup_borders(pSlice_image->get_block_width(4) * 4, pSlice_image->get_block_height(4) * 4); |
| |
| if (m_params.m_debug_images) |
| { |
| if (m_params.m_hdr) |
| write_exr(string_format("basis_debug_source_image_%u_slice_%u.exr", source_file_index, slice_index).c_str(), *pSlice_image_hdr, 3, 0); |
| else |
| save_png(string_format("basis_debug_source_image_%u_slice_%u.png", source_file_index, slice_index).c_str(), *pSlice_image); |
| } |
| |
| const uint32_t dest_image_index = (m_params.m_hdr ? m_slice_images_hdr.size() : m_slice_images.size()); |
| |
| enlarge_vector(m_stats, 1); |
| |
| if (m_params.m_hdr) |
| enlarge_vector(m_slice_images_hdr, 1); |
| else |
| enlarge_vector(m_slice_images, 1); |
| |
| enlarge_vector(m_slice_descs, 1); |
| |
| m_stats[dest_image_index].m_filename = source_filename.c_str(); |
| m_stats[dest_image_index].m_width = orig_width; |
| m_stats[dest_image_index].m_height = orig_height; |
| |
| debug_printf("****** Slice %u: mip %u, alpha_slice: %u, filename: \"%s\", original: %ux%u actual: %ux%u\n", |
| m_slice_descs.size() - 1, mip_indices[slice_index], is_alpha_slice, source_filename.c_str(), |
| orig_width, orig_height, |
| m_params.m_hdr ? pSlice_image_hdr->get_width() : pSlice_image->get_width(), |
| m_params.m_hdr ? pSlice_image_hdr->get_height() : pSlice_image->get_height()); |
| |
| basisu_backend_slice_desc& slice_desc = m_slice_descs[dest_image_index]; |
| |
| slice_desc.m_first_block_index = m_total_blocks; |
| |
| slice_desc.m_orig_width = orig_width; |
| slice_desc.m_orig_height = orig_height; |
| |
| if (m_params.m_hdr) |
| { |
| slice_desc.m_width = pSlice_image_hdr->get_width(); |
| slice_desc.m_height = pSlice_image_hdr->get_height(); |
| |
| slice_desc.m_num_blocks_x = pSlice_image_hdr->get_block_width(4); |
| slice_desc.m_num_blocks_y = pSlice_image_hdr->get_block_height(4); |
| } |
| else |
| { |
| slice_desc.m_width = pSlice_image->get_width(); |
| slice_desc.m_height = pSlice_image->get_height(); |
| |
| slice_desc.m_num_blocks_x = pSlice_image->get_block_width(4); |
| slice_desc.m_num_blocks_y = pSlice_image->get_block_height(4); |
| } |
| |
| slice_desc.m_num_macroblocks_x = (slice_desc.m_num_blocks_x + 1) >> 1; |
| slice_desc.m_num_macroblocks_y = (slice_desc.m_num_blocks_y + 1) >> 1; |
| |
| slice_desc.m_source_file_index = source_file_index; |
| |
| slice_desc.m_mip_index = mip_indices[slice_index]; |
| |
| slice_desc.m_alpha = is_alpha_slice; |
| slice_desc.m_iframe = false; |
| if (m_params.m_tex_type == basist::cBASISTexTypeVideoFrames) |
| { |
| slice_desc.m_iframe = (source_file_index == 0); |
| } |
| |
| m_total_blocks += slice_desc.m_num_blocks_x * slice_desc.m_num_blocks_y; |
| total_macroblocks += slice_desc.m_num_macroblocks_x * slice_desc.m_num_macroblocks_y; |
| |
| // Finally, swap in the slice's image to avoid copying it. |
| // NOTE: slice_image is now blank. |
| if (m_params.m_hdr) |
| m_slice_images_hdr[dest_image_index].swap(*pSlice_image_hdr); |
| else |
| m_slice_images[dest_image_index].swap(*pSlice_image); |
| |
| } // slice_index |
| |
| } // source_file_index |
| |
| debug_printf("Total blocks: %u, Total macroblocks: %u\n", m_total_blocks, total_macroblocks); |
| |
| // Make sure we don't have too many slices |
| if (m_slice_descs.size() > BASISU_MAX_SLICES) |
| { |
| error_printf("Too many slices!\n"); |
| return false; |
| } |
| |
| // Basic sanity check on the slices |
| for (uint32_t i = 1; i < m_slice_descs.size(); i++) |
| { |
| const basisu_backend_slice_desc &prev_slice_desc = m_slice_descs[i - 1]; |
| const basisu_backend_slice_desc &slice_desc = m_slice_descs[i]; |
| |
| // Make sure images are in order |
| int image_delta = (int)slice_desc.m_source_file_index - (int)prev_slice_desc.m_source_file_index; |
| if (image_delta > 1) |
| return false; |
| |
| // Make sure mipmap levels are in order |
| if (!image_delta) |
| { |
| int level_delta = (int)slice_desc.m_mip_index - (int)prev_slice_desc.m_mip_index; |
| if (level_delta > 1) |
| return false; |
| } |
| } |
| |
| if (m_params.m_status_output) |
| { |
| printf("Total slices: %u\n", (uint32_t)m_slice_descs.size()); |
| } |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| const basisu_backend_slice_desc &slice_desc = m_slice_descs[i]; |
| |
| if (m_params.m_status_output) |
| { |
| printf("Slice: %u, alpha: %u, orig width/height: %ux%u, width/height: %ux%u, first_block: %u, image_index: %u, mip_level: %u, iframe: %u\n", |
| i, slice_desc.m_alpha, slice_desc.m_orig_width, slice_desc.m_orig_height, |
| slice_desc.m_width, slice_desc.m_height, |
| slice_desc.m_first_block_index, slice_desc.m_source_file_index, slice_desc.m_mip_index, slice_desc.m_iframe); |
| } |
| |
| if (m_any_source_image_has_alpha) |
| { |
| // HDR doesn't support alpha yet |
| if (m_params.m_hdr) |
| return false; |
| |
| if (!m_params.m_uastc) |
| { |
| // For ETC1S, alpha slices must be at odd slice indices. |
| if (slice_desc.m_alpha) |
| { |
| if ((i & 1) == 0) |
| return false; |
| |
| const basisu_backend_slice_desc& prev_slice_desc = m_slice_descs[i - 1]; |
| |
| // Make sure previous slice has this image's color data |
| if (prev_slice_desc.m_source_file_index != slice_desc.m_source_file_index) |
| return false; |
| if (prev_slice_desc.m_alpha) |
| return false; |
| if (prev_slice_desc.m_mip_index != slice_desc.m_mip_index) |
| return false; |
| if (prev_slice_desc.m_num_blocks_x != slice_desc.m_num_blocks_x) |
| return false; |
| if (prev_slice_desc.m_num_blocks_y != slice_desc.m_num_blocks_y) |
| return false; |
| } |
| else if (i & 1) |
| return false; |
| } |
| } |
| else if (slice_desc.m_alpha) |
| { |
| return false; |
| } |
| |
| if ((slice_desc.m_orig_width > slice_desc.m_width) || (slice_desc.m_orig_height > slice_desc.m_height)) |
| return false; |
| |
| if ((slice_desc.m_source_file_index == 0) && (m_params.m_tex_type == basist::cBASISTexTypeVideoFrames)) |
| { |
| if (!slice_desc.m_iframe) |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| // Do some basic validation for 2D arrays, cubemaps, video, and volumes. |
| bool basis_compressor::validate_texture_type_constraints() |
| { |
| debug_printf("basis_compressor::validate_texture_type_constraints\n"); |
| |
| // In 2D mode anything goes (each image may have a different resolution and # of mipmap levels). |
| if (m_params.m_tex_type == basist::cBASISTexType2D) |
| return true; |
| |
| uint32_t total_basis_images = 0; |
| |
| for (uint32_t slice_index = 0; slice_index < (m_params.m_hdr ? m_slice_images_hdr.size() : m_slice_images.size()); slice_index++) |
| { |
| const basisu_backend_slice_desc &slice_desc = m_slice_descs[slice_index]; |
| |
| total_basis_images = maximum<uint32_t>(total_basis_images, slice_desc.m_source_file_index + 1); |
| } |
| |
| if (m_params.m_tex_type == basist::cBASISTexTypeCubemapArray) |
| { |
| // For cubemaps, validate that the total # of Basis images is a multiple of 6. |
| if ((total_basis_images % 6) != 0) |
| { |
| error_printf("basis_compressor::validate_texture_type_constraints: For cubemaps the total number of input images is not a multiple of 6!\n"); |
| return false; |
| } |
| } |
| |
| // Now validate that all the mip0's have the same dimensions, and that each image has the same # of mipmap levels. |
| uint_vec image_mipmap_levels(total_basis_images); |
| |
| int width = -1, height = -1; |
| for (uint32_t slice_index = 0; slice_index < (m_params.m_hdr ? m_slice_images_hdr.size() : m_slice_images.size()); slice_index++) |
| { |
| const basisu_backend_slice_desc &slice_desc = m_slice_descs[slice_index]; |
| |
| image_mipmap_levels[slice_desc.m_source_file_index] = maximum(image_mipmap_levels[slice_desc.m_source_file_index], slice_desc.m_mip_index + 1); |
| |
| if (slice_desc.m_mip_index != 0) |
| continue; |
| |
| if (width < 0) |
| { |
| width = slice_desc.m_orig_width; |
| height = slice_desc.m_orig_height; |
| } |
| else if ((width != (int)slice_desc.m_orig_width) || (height != (int)slice_desc.m_orig_height)) |
| { |
| error_printf("basis_compressor::validate_texture_type_constraints: The source image resolutions are not all equal!\n"); |
| return false; |
| } |
| } |
| |
| for (size_t i = 1; i < image_mipmap_levels.size(); i++) |
| { |
| if (image_mipmap_levels[0] != image_mipmap_levels[i]) |
| { |
| error_printf("basis_compressor::validate_texture_type_constraints: Each image must have the same number of mipmap levels!\n"); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::extract_source_blocks() |
| { |
| debug_printf("basis_compressor::extract_source_blocks\n"); |
| |
| if (m_params.m_hdr) |
| m_source_blocks_hdr.resize(m_total_blocks); |
| else |
| m_source_blocks.resize(m_total_blocks); |
| |
| for (uint32_t slice_index = 0; slice_index < (m_params.m_hdr ? m_slice_images_hdr.size() : m_slice_images.size()); slice_index++) |
| { |
| const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| |
| const uint32_t num_blocks_x = slice_desc.m_num_blocks_x; |
| const uint32_t num_blocks_y = slice_desc.m_num_blocks_y; |
| |
| const image *pSource_image = m_params.m_hdr ? nullptr : &m_slice_images[slice_index]; |
| const imagef *pSource_image_hdr = m_params.m_hdr ? &m_slice_images_hdr[slice_index] : nullptr; |
| |
| for (uint32_t block_y = 0; block_y < num_blocks_y; block_y++) |
| { |
| for (uint32_t block_x = 0; block_x < num_blocks_x; block_x++) |
| { |
| if (m_params.m_hdr) |
| { |
| vec4F* pBlock = m_source_blocks_hdr[slice_desc.m_first_block_index + block_x + block_y * num_blocks_x].get_ptr(); |
| |
| pSource_image_hdr->extract_block_clamped(pBlock, block_x * 4, block_y * 4, 4, 4); |
| |
| // Additional (technically optional) early sanity checking of the block texels. |
| for (uint32_t i = 0; i < 16; i++) |
| { |
| for (uint32_t c = 0; c < 3; c++) |
| { |
| float v = pBlock[i][c]; |
| |
| if (std::isnan(v) || std::isinf(v) || (v < 0.0f) || (v > basist::MAX_HALF_FLOAT)) |
| { |
| error_printf("basis_compressor::extract_source_blocks: invalid float component\n"); |
| return false; |
| } |
| } |
| } |
| } |
| else |
| { |
| pSource_image->extract_block_clamped(m_source_blocks[slice_desc.m_first_block_index + block_x + block_y * num_blocks_x].get_ptr(), block_x * 4, block_y * 4, 4, 4); |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::process_frontend() |
| { |
| debug_printf("basis_compressor::process_frontend\n"); |
| |
| #if 0 |
| // TODO |
| basis_etc1_pack_params pack_params; |
| pack_params.m_quality = cETCQualityMedium; |
| pack_params.m_perceptual = m_params.m_perceptual; |
| pack_params.m_use_color4 = false; |
| |
| pack_etc1_block_context pack_context; |
| |
| std::unordered_set<uint64_t> endpoint_hash; |
| std::unordered_set<uint32_t> selector_hash; |
| |
| for (uint32_t i = 0; i < m_source_blocks.size(); i++) |
| { |
| etc_block blk; |
| pack_etc1_block(blk, m_source_blocks[i].get_ptr(), pack_params, pack_context); |
| |
| const color_rgba c0(blk.get_block_color(0, false)); |
| endpoint_hash.insert((c0.r | (c0.g << 5) | (c0.b << 10)) | (blk.get_inten_table(0) << 16)); |
| |
| const color_rgba c1(blk.get_block_color(1, false)); |
| endpoint_hash.insert((c1.r | (c1.g << 5) | (c1.b << 10)) | (blk.get_inten_table(1) << 16)); |
| |
| selector_hash.insert(blk.get_raw_selector_bits()); |
| } |
| |
| const uint32_t total_unique_endpoints = (uint32_t)endpoint_hash.size(); |
| const uint32_t total_unique_selectors = (uint32_t)selector_hash.size(); |
| |
| if (m_params.m_debug) |
| { |
| debug_printf("Unique endpoints: %u, unique selectors: %u\n", total_unique_endpoints, total_unique_selectors); |
| } |
| #endif |
| |
| const double total_texels = m_total_blocks * 16.0f; |
| |
| int endpoint_clusters = m_params.m_max_endpoint_clusters; |
| int selector_clusters = m_params.m_max_selector_clusters; |
| |
| if (endpoint_clusters > basisu_frontend::cMaxEndpointClusters) |
| { |
| error_printf("Too many endpoint clusters! (%u but max is %u)\n", endpoint_clusters, basisu_frontend::cMaxEndpointClusters); |
| return false; |
| } |
| if (selector_clusters > basisu_frontend::cMaxSelectorClusters) |
| { |
| error_printf("Too many selector clusters! (%u but max is %u)\n", selector_clusters, basisu_frontend::cMaxSelectorClusters); |
| return false; |
| } |
| |
| if (m_params.m_quality_level != -1) |
| { |
| const float quality = saturate(m_params.m_quality_level / 255.0f); |
| |
| const float bits_per_endpoint_cluster = 14.0f; |
| const float max_desired_endpoint_cluster_bits_per_texel = 1.0f; // .15f |
| int max_endpoints = static_cast<int>((max_desired_endpoint_cluster_bits_per_texel * total_texels) / bits_per_endpoint_cluster); |
| |
| const float mid = 128.0f / 255.0f; |
| |
| float color_endpoint_quality = quality; |
| |
| const float endpoint_split_point = 0.5f; |
| |
| // In v1.2 and in previous versions, the endpoint codebook size at quality 128 was 3072. This wasn't quite large enough. |
| const int ENDPOINT_CODEBOOK_MID_QUALITY_CODEBOOK_SIZE = 4800; |
| const int MAX_ENDPOINT_CODEBOOK_SIZE = 8192; |
| |
| if (color_endpoint_quality <= mid) |
| { |
| color_endpoint_quality = lerp(0.0f, endpoint_split_point, powf(color_endpoint_quality / mid, .65f)); |
| |
| max_endpoints = clamp<int>(max_endpoints, 256, ENDPOINT_CODEBOOK_MID_QUALITY_CODEBOOK_SIZE); |
| max_endpoints = minimum<uint32_t>(max_endpoints, m_total_blocks); |
| |
| if (max_endpoints < 64) |
| max_endpoints = 64; |
| endpoint_clusters = clamp<uint32_t>((uint32_t)(.5f + lerp<float>(32, static_cast<float>(max_endpoints), color_endpoint_quality)), 32, basisu_frontend::cMaxEndpointClusters); |
| } |
| else |
| { |
| color_endpoint_quality = powf((color_endpoint_quality - mid) / (1.0f - mid), 1.6f); |
| |
| max_endpoints = clamp<int>(max_endpoints, 256, MAX_ENDPOINT_CODEBOOK_SIZE); |
| max_endpoints = minimum<uint32_t>(max_endpoints, m_total_blocks); |
| |
| if (max_endpoints < ENDPOINT_CODEBOOK_MID_QUALITY_CODEBOOK_SIZE) |
| max_endpoints = ENDPOINT_CODEBOOK_MID_QUALITY_CODEBOOK_SIZE; |
| endpoint_clusters = clamp<uint32_t>((uint32_t)(.5f + lerp<float>(ENDPOINT_CODEBOOK_MID_QUALITY_CODEBOOK_SIZE, static_cast<float>(max_endpoints), color_endpoint_quality)), 32, basisu_frontend::cMaxEndpointClusters); |
| } |
| |
| float bits_per_selector_cluster = 14.0f; |
| |
| const float max_desired_selector_cluster_bits_per_texel = 1.0f; // .15f |
| int max_selectors = static_cast<int>((max_desired_selector_cluster_bits_per_texel * total_texels) / bits_per_selector_cluster); |
| max_selectors = clamp<int>(max_selectors, 256, basisu_frontend::cMaxSelectorClusters); |
| max_selectors = minimum<uint32_t>(max_selectors, m_total_blocks); |
| |
| float color_selector_quality = quality; |
| //color_selector_quality = powf(color_selector_quality, 1.65f); |
| color_selector_quality = powf(color_selector_quality, 2.62f); |
| |
| if (max_selectors < 96) |
| max_selectors = 96; |
| selector_clusters = clamp<uint32_t>((uint32_t)(.5f + lerp<float>(96, static_cast<float>(max_selectors), color_selector_quality)), 8, basisu_frontend::cMaxSelectorClusters); |
| |
| debug_printf("Max endpoints: %u, max selectors: %u\n", endpoint_clusters, selector_clusters); |
| |
| if (m_params.m_quality_level >= 223) |
| { |
| if (!m_params.m_selector_rdo_thresh.was_changed()) |
| { |
| if (!m_params.m_endpoint_rdo_thresh.was_changed()) |
| m_params.m_endpoint_rdo_thresh *= .25f; |
| |
| if (!m_params.m_selector_rdo_thresh.was_changed()) |
| m_params.m_selector_rdo_thresh *= .25f; |
| } |
| } |
| else if (m_params.m_quality_level >= 192) |
| { |
| if (!m_params.m_endpoint_rdo_thresh.was_changed()) |
| m_params.m_endpoint_rdo_thresh *= .5f; |
| |
| if (!m_params.m_selector_rdo_thresh.was_changed()) |
| m_params.m_selector_rdo_thresh *= .5f; |
| } |
| else if (m_params.m_quality_level >= 160) |
| { |
| if (!m_params.m_endpoint_rdo_thresh.was_changed()) |
| m_params.m_endpoint_rdo_thresh *= .75f; |
| |
| if (!m_params.m_selector_rdo_thresh.was_changed()) |
| m_params.m_selector_rdo_thresh *= .75f; |
| } |
| else if (m_params.m_quality_level >= 129) |
| { |
| float l = (quality - 129 / 255.0f) / ((160 - 129) / 255.0f); |
| |
| if (!m_params.m_endpoint_rdo_thresh.was_changed()) |
| m_params.m_endpoint_rdo_thresh *= lerp<float>(1.0f, .75f, l); |
| |
| if (!m_params.m_selector_rdo_thresh.was_changed()) |
| m_params.m_selector_rdo_thresh *= lerp<float>(1.0f, .75f, l); |
| } |
| } |
| |
| basisu_frontend::params p; |
| p.m_num_source_blocks = m_total_blocks; |
| p.m_pSource_blocks = &m_source_blocks[0]; |
| p.m_max_endpoint_clusters = endpoint_clusters; |
| p.m_max_selector_clusters = selector_clusters; |
| p.m_perceptual = m_params.m_perceptual; |
| p.m_debug_stats = m_params.m_debug; |
| p.m_debug_images = m_params.m_debug_images; |
| p.m_compression_level = m_params.m_compression_level; |
| p.m_tex_type = m_params.m_tex_type; |
| p.m_multithreaded = m_params.m_multithreading; |
| p.m_disable_hierarchical_endpoint_codebooks = m_params.m_disable_hierarchical_endpoint_codebooks; |
| p.m_validate = m_params.m_validate_etc1s; |
| p.m_pJob_pool = m_params.m_pJob_pool; |
| p.m_pGlobal_codebooks = m_params.m_pGlobal_codebooks; |
| |
| // Don't keep trying to use OpenCL if it ever fails. |
| p.m_pOpenCL_context = !m_opencl_failed ? m_pOpenCL_context : nullptr; |
| |
| if (!m_frontend.init(p)) |
| { |
| error_printf("basisu_frontend::init() failed!\n"); |
| return false; |
| } |
| |
| m_frontend.compress(); |
| |
| if (m_frontend.get_opencl_failed()) |
| m_opencl_failed = true; |
| |
| if (m_params.m_debug_images) |
| { |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| char filename[1024]; |
| #ifdef _WIN32 |
| sprintf_s(filename, sizeof(filename), "rdo_frontend_output_output_blocks_%u.png", i); |
| #else |
| snprintf(filename, sizeof(filename), "rdo_frontend_output_output_blocks_%u.png", i); |
| #endif |
| m_frontend.dump_debug_image(filename, m_slice_descs[i].m_first_block_index, m_slice_descs[i].m_num_blocks_x, m_slice_descs[i].m_num_blocks_y, true); |
| |
| #ifdef _WIN32 |
| sprintf_s(filename, sizeof(filename), "rdo_frontend_output_api_%u.png", i); |
| #else |
| snprintf(filename, sizeof(filename), "rdo_frontend_output_api_%u.png", i); |
| #endif |
| m_frontend.dump_debug_image(filename, m_slice_descs[i].m_first_block_index, m_slice_descs[i].m_num_blocks_x, m_slice_descs[i].m_num_blocks_y, false); |
| } |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::extract_frontend_texture_data() |
| { |
| if (!m_params.m_compute_stats) |
| return true; |
| |
| debug_printf("basis_compressor::extract_frontend_texture_data\n"); |
| |
| m_frontend_output_textures.resize(m_slice_descs.size()); |
| m_best_etc1s_images.resize(m_slice_descs.size()); |
| m_best_etc1s_images_unpacked.resize(m_slice_descs.size()); |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| const basisu_backend_slice_desc &slice_desc = m_slice_descs[i]; |
| |
| const uint32_t num_blocks_x = slice_desc.m_num_blocks_x; |
| const uint32_t num_blocks_y = slice_desc.m_num_blocks_y; |
| |
| const uint32_t width = num_blocks_x * 4; |
| const uint32_t height = num_blocks_y * 4; |
| |
| m_frontend_output_textures[i].init(texture_format::cETC1, width, height); |
| |
| for (uint32_t block_y = 0; block_y < num_blocks_y; block_y++) |
| for (uint32_t block_x = 0; block_x < num_blocks_x; block_x++) |
| memcpy(m_frontend_output_textures[i].get_block_ptr(block_x, block_y, 0), &m_frontend.get_output_block(slice_desc.m_first_block_index + block_x + block_y * num_blocks_x), sizeof(etc_block)); |
| |
| #if 0 |
| if (m_params.m_debug_images) |
| { |
| char filename[1024]; |
| sprintf_s(filename, sizeof(filename), "rdo_etc_frontend_%u_", i); |
| write_etc1_vis_images(m_frontend_output_textures[i], filename); |
| } |
| #endif |
| |
| m_best_etc1s_images[i].init(texture_format::cETC1, width, height); |
| for (uint32_t block_y = 0; block_y < num_blocks_y; block_y++) |
| for (uint32_t block_x = 0; block_x < num_blocks_x; block_x++) |
| memcpy(m_best_etc1s_images[i].get_block_ptr(block_x, block_y, 0), &m_frontend.get_etc1s_block(slice_desc.m_first_block_index + block_x + block_y * num_blocks_x), sizeof(etc_block)); |
| |
| m_best_etc1s_images[i].unpack(m_best_etc1s_images_unpacked[i]); |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::process_backend() |
| { |
| debug_printf("basis_compressor::process_backend\n"); |
| |
| basisu_backend_params backend_params; |
| backend_params.m_debug = m_params.m_debug; |
| backend_params.m_debug_images = m_params.m_debug_images; |
| backend_params.m_etc1s = true; |
| backend_params.m_compression_level = m_params.m_compression_level; |
| |
| if (!m_params.m_no_endpoint_rdo) |
| backend_params.m_endpoint_rdo_quality_thresh = m_params.m_endpoint_rdo_thresh; |
| |
| if (!m_params.m_no_selector_rdo) |
| backend_params.m_selector_rdo_quality_thresh = m_params.m_selector_rdo_thresh; |
| |
| backend_params.m_used_global_codebooks = m_frontend.get_params().m_pGlobal_codebooks != nullptr; |
| backend_params.m_validate = m_params.m_validate_output_data; |
| |
| m_backend.init(&m_frontend, backend_params, m_slice_descs); |
| uint32_t total_packed_bytes = m_backend.encode(); |
| |
| if (!total_packed_bytes) |
| { |
| error_printf("basis_compressor::encode() failed!\n"); |
| return false; |
| } |
| |
| debug_printf("Total packed bytes (estimated): %u\n", total_packed_bytes); |
| |
| return true; |
| } |
| |
| bool basis_compressor::create_basis_file_and_transcode() |
| { |
| debug_printf("basis_compressor::create_basis_file_and_transcode\n"); |
| |
| const basisu_backend_output& encoded_output = m_params.m_uastc ? m_uastc_backend_output : m_backend.get_output(); |
| |
| if (!m_basis_file.init(encoded_output, m_params.m_tex_type, m_params.m_userdata0, m_params.m_userdata1, m_params.m_y_flip, m_params.m_us_per_frame)) |
| { |
| error_printf("basis_compressor::create_basis_file_and_transcode: basisu_backend:init() failed!\n"); |
| return false; |
| } |
| |
| const uint8_vec &comp_data = m_basis_file.get_compressed_data(); |
| |
| m_output_basis_file = comp_data; |
| |
| uint32_t total_orig_pixels = 0, total_texels = 0, total_orig_texels = 0; |
| (void)total_texels; |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| const basisu_backend_slice_desc& slice_desc = m_slice_descs[i]; |
| |
| total_orig_pixels += slice_desc.m_orig_width * slice_desc.m_orig_height; |
| total_texels += slice_desc.m_width * slice_desc.m_height; |
| } |
| |
| m_basis_file_size = (uint32_t)comp_data.size(); |
| m_basis_bits_per_texel = total_orig_texels ? (comp_data.size() * 8.0f) / total_orig_texels : 0; |
| |
| debug_printf("Total .basis output file size: %u, %3.3f bits/texel\n", comp_data.size(), comp_data.size() * 8.0f / total_orig_pixels); |
| |
| if (m_params.m_validate_output_data) |
| { |
| interval_timer tm; |
| tm.start(); |
| |
| basist::basisu_transcoder_init(); |
| |
| debug_printf("basist::basisu_transcoder_init: Took %f ms\n", tm.get_elapsed_ms()); |
| |
| // Verify the compressed data by transcoding it to ASTC (or ETC1)/BC7 and validating the CRC's. |
| basist::basisu_transcoder decoder; |
| if (!decoder.validate_file_checksums(&comp_data[0], (uint32_t)comp_data.size(), true)) |
| { |
| error_printf("decoder.validate_file_checksums() failed!\n"); |
| return false; |
| } |
| |
| m_decoded_output_textures.resize(m_slice_descs.size()); |
| |
| if (m_params.m_hdr) |
| { |
| m_decoded_output_textures_bc6h_hdr_unpacked.resize(m_slice_descs.size()); |
| |
| m_decoded_output_textures_astc_hdr.resize(m_slice_descs.size()); |
| m_decoded_output_textures_astc_hdr_unpacked.resize(m_slice_descs.size()); |
| } |
| else |
| { |
| m_decoded_output_textures_unpacked.resize(m_slice_descs.size()); |
| |
| m_decoded_output_textures_bc7.resize(m_slice_descs.size()); |
| m_decoded_output_textures_unpacked_bc7.resize(m_slice_descs.size()); |
| } |
| |
| tm.start(); |
| if (m_params.m_pGlobal_codebooks) |
| { |
| decoder.set_global_codebooks(m_params.m_pGlobal_codebooks); |
| } |
| |
| if (!decoder.start_transcoding(&comp_data[0], (uint32_t)comp_data.size())) |
| { |
| error_printf("decoder.start_transcoding() failed!\n"); |
| return false; |
| } |
| |
| double start_transcoding_time = tm.get_elapsed_secs(); |
| |
| debug_printf("basisu_compressor::start_transcoding() took %3.3fms\n", start_transcoding_time * 1000.0f); |
| |
| double total_time_etc1s_or_astc = 0; |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| basisu::texture_format tex_format = m_params.m_hdr ? texture_format::cBC6HUnsigned : (m_params.m_uastc ? texture_format::cUASTC4x4 : texture_format::cETC1); |
| basist::block_format format = m_params.m_hdr ? basist::block_format::cBC6H : (m_params.m_uastc ? basist::block_format::cUASTC_4x4 : basist::block_format::cETC1); |
| |
| gpu_image decoded_texture; |
| decoded_texture.init( |
| tex_format, |
| m_slice_descs[i].m_width, m_slice_descs[i].m_height); |
| |
| tm.start(); |
| |
| uint32_t bytes_per_block = m_params.m_uastc ? 16 : 8; |
| |
| if (!decoder.transcode_slice(&comp_data[0], (uint32_t)comp_data.size(), i, |
| reinterpret_cast<etc_block*>(decoded_texture.get_ptr()), m_slice_descs[i].m_num_blocks_x * m_slice_descs[i].m_num_blocks_y, format, bytes_per_block)) |
| { |
| error_printf("Transcoding failed on slice %u!\n", i); |
| return false; |
| } |
| |
| total_time_etc1s_or_astc += tm.get_elapsed_secs(); |
| |
| if (encoded_output.m_tex_format == basist::basis_tex_format::cETC1S) |
| { |
| uint32_t image_crc16 = basist::crc16(decoded_texture.get_ptr(), decoded_texture.get_size_in_bytes(), 0); |
| if (image_crc16 != encoded_output.m_slice_image_crcs[i]) |
| { |
| error_printf("Decoded image data CRC check failed on slice %u!\n", i); |
| return false; |
| } |
| debug_printf("Decoded image data CRC check succeeded on slice %i\n", i); |
| } |
| |
| m_decoded_output_textures[i] = decoded_texture; |
| } |
| |
| double total_alt_transcode_time = 0; |
| tm.start(); |
| |
| if (m_params.m_hdr) |
| { |
| assert(basist::basis_is_format_supported(basist::transcoder_texture_format::cTFASTC_HDR_4x4_RGBA, basist::basis_tex_format::cUASTC_HDR_4x4)); |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| gpu_image decoded_texture; |
| decoded_texture.init(texture_format::cASTC_HDR_4x4, m_slice_descs[i].m_width, m_slice_descs[i].m_height); |
| |
| tm.start(); |
| |
| if (!decoder.transcode_slice(&comp_data[0], (uint32_t)comp_data.size(), i, |
| reinterpret_cast<basist::astc_blk*>(decoded_texture.get_ptr()), m_slice_descs[i].m_num_blocks_x * m_slice_descs[i].m_num_blocks_y, basist::block_format::cASTC_HDR_4x4, 16)) |
| { |
| error_printf("Transcoding failed to ASTC HDR on slice %u!\n", i); |
| return false; |
| } |
| |
| m_decoded_output_textures_astc_hdr[i] = decoded_texture; |
| } |
| } |
| else |
| { |
| if (basist::basis_is_format_supported(basist::transcoder_texture_format::cTFBC7_RGBA, basist::basis_tex_format::cUASTC4x4) && |
| basist::basis_is_format_supported(basist::transcoder_texture_format::cTFBC7_RGBA, basist::basis_tex_format::cETC1S)) |
| { |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| gpu_image decoded_texture; |
| decoded_texture.init(texture_format::cBC7, m_slice_descs[i].m_width, m_slice_descs[i].m_height); |
| |
| if (!decoder.transcode_slice(&comp_data[0], (uint32_t)comp_data.size(), i, |
| reinterpret_cast<etc_block*>(decoded_texture.get_ptr()), m_slice_descs[i].m_num_blocks_x * m_slice_descs[i].m_num_blocks_y, basist::block_format::cBC7, 16)) |
| { |
| error_printf("Transcoding failed to BC7 on slice %u!\n", i); |
| return false; |
| } |
| |
| m_decoded_output_textures_bc7[i] = decoded_texture; |
| } |
| } |
| } |
| |
| total_alt_transcode_time = tm.get_elapsed_secs(); |
| |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| { |
| if (m_params.m_hdr) |
| { |
| // BC6H |
| bool status = m_decoded_output_textures[i].unpack_hdr(m_decoded_output_textures_bc6h_hdr_unpacked[i]); |
| assert(status); |
| BASISU_NOTE_UNUSED(status); |
| |
| // ASTC HDR |
| status = m_decoded_output_textures_astc_hdr[i].unpack_hdr(m_decoded_output_textures_astc_hdr_unpacked[i]); |
| assert(status); |
| } |
| else |
| { |
| bool status = m_decoded_output_textures[i].unpack(m_decoded_output_textures_unpacked[i]); |
| assert(status); |
| BASISU_NOTE_UNUSED(status); |
| |
| if (m_decoded_output_textures_bc7[i].get_pixel_width()) |
| { |
| status = m_decoded_output_textures_bc7[i].unpack(m_decoded_output_textures_unpacked_bc7[i]); |
| assert(status); |
| } |
| } |
| } |
| |
| debug_printf("Transcoded to %s in %3.3fms, %f texels/sec\n", |
| m_params.m_hdr ? "BC6H" : (m_params.m_uastc ? "ASTC" : "ETC1"), |
| total_time_etc1s_or_astc * 1000.0f, total_orig_pixels / total_time_etc1s_or_astc); |
| |
| if (total_alt_transcode_time != 0) |
| debug_printf("Alternate transcode in %3.3fms, %f texels/sec\n", total_alt_transcode_time * 1000.0f, total_orig_pixels / total_alt_transcode_time); |
| |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| { |
| const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| |
| const uint32_t total_blocks = slice_desc.m_num_blocks_x * slice_desc.m_num_blocks_y; |
| BASISU_NOTE_UNUSED(total_blocks); |
| |
| assert(m_decoded_output_textures[slice_index].get_total_blocks() == total_blocks); |
| } |
| |
| } // if (m_params.m_validate_output_data) |
| |
| return true; |
| } |
| |
| bool basis_compressor::write_hdr_debug_images(const char* pBasename, const imagef& orig_hdr_img, uint32_t width, uint32_t height) |
| { |
| // Copy image to account for 4x4 block expansion |
| imagef hdr_img(orig_hdr_img); |
| hdr_img.resize(width, height); |
| |
| image srgb_img(width, height); |
| |
| for (uint32_t y = 0; y < height; y++) |
| { |
| for (uint32_t x = 0; x < width; x++) |
| { |
| vec4F p(hdr_img(x, y)); |
| |
| p[0] = clamp(p[0], 0.0f, 1.0f); |
| p[1] = clamp(p[1], 0.0f, 1.0f); |
| p[2] = clamp(p[2], 0.0f, 1.0f); |
| |
| int rc = (int)std::round(linear_to_srgb(p[0]) * 255.0f); |
| int gc = (int)std::round(linear_to_srgb(p[1]) * 255.0f); |
| int bc = (int)std::round(linear_to_srgb(p[2]) * 255.0f); |
| |
| srgb_img.set_clipped(x, y, color_rgba(rc, gc, bc, 255)); |
| } |
| } |
| |
| { |
| const std::string filename(string_format("%s_linear_clamped_to_srgb.png", pBasename)); |
| save_png(filename.c_str(), srgb_img); |
| printf("Wrote .PNG file %s\n", filename.c_str()); |
| } |
| |
| { |
| const std::string filename(string_format("%s_compressive_tonemapped.png", pBasename)); |
| image compressive_tonemapped_img; |
| |
| bool status = tonemap_image_compressive(compressive_tonemapped_img, hdr_img); |
| if (!status) |
| { |
| error_printf("basis_compressor::write_hdr_debug_images: tonemap_image_compressive() failed (invalid half-float input)\n"); |
| } |
| else |
| { |
| save_png(filename.c_str(), compressive_tonemapped_img); |
| printf("Wrote .PNG file %s\n", filename.c_str()); |
| } |
| } |
| |
| image tonemapped_img; |
| |
| for (int e = -5; e <= 5; e++) |
| { |
| const float scale = powf(2.0f, (float)e); |
| |
| tonemap_image_reinhard(tonemapped_img, hdr_img, scale); |
| |
| std::string filename(string_format("%s_reinhard_tonemapped_scale_%f.png", pBasename, scale)); |
| save_png(filename.c_str(), tonemapped_img, cImageSaveIgnoreAlpha); |
| printf("Wrote .PNG file %s\n", filename.c_str()); |
| } |
| |
| return true; |
| } |
| |
| bool basis_compressor::write_output_files_and_compute_stats() |
| { |
| debug_printf("basis_compressor::write_output_files_and_compute_stats\n"); |
| |
| const uint8_vec& comp_data = m_params.m_create_ktx2_file ? m_output_ktx2_file : m_basis_file.get_compressed_data(); |
| if (m_params.m_write_output_basis_or_ktx2_files) |
| { |
| const std::string& output_filename = m_params.m_out_filename; |
| |
| if (!write_vec_to_file(output_filename.c_str(), comp_data)) |
| { |
| error_printf("Failed writing output data to file \"%s\"\n", output_filename.c_str()); |
| return false; |
| } |
| |
| if (m_params.m_status_output) |
| { |
| printf("Wrote output .basis/.ktx2 file \"%s\"\n", output_filename.c_str()); |
| } |
| } |
| |
| size_t comp_size = 0; |
| if ((m_params.m_compute_stats) && (m_params.m_uastc) && (comp_data.size())) |
| { |
| void* pComp_data = tdefl_compress_mem_to_heap(&comp_data[0], comp_data.size(), &comp_size, TDEFL_MAX_PROBES_MASK);// TDEFL_DEFAULT_MAX_PROBES); |
| size_t decomp_size = 0; |
| void* pDecomp_data = tinfl_decompress_mem_to_heap(pComp_data, comp_size, &decomp_size, 0); |
| if ((decomp_size != comp_data.size()) || (memcmp(pDecomp_data, &comp_data[0], decomp_size) != 0)) |
| { |
| printf("basis_compressor::create_basis_file_and_transcode:: miniz compression or decompression failed!\n"); |
| return false; |
| } |
| |
| mz_free(pComp_data); |
| mz_free(pDecomp_data); |
| |
| uint32_t total_texels = 0; |
| for (uint32_t i = 0; i < m_slice_descs.size(); i++) |
| total_texels += (m_slice_descs[i].m_num_blocks_x * m_slice_descs[i].m_num_blocks_y) * 16; |
| |
| m_basis_bits_per_texel = comp_size * 8.0f / total_texels; |
| |
| debug_printf("Output file size: %u, LZ compressed file size: %u, %3.2f bits/texel\n", |
| (uint32_t)comp_data.size(), |
| (uint32_t)comp_size, |
| m_basis_bits_per_texel); |
| } |
| |
| m_stats.resize(m_slice_descs.size()); |
| |
| if (m_params.m_validate_output_data) |
| { |
| if (m_params.m_hdr) |
| { |
| if (m_params.m_print_stats) |
| { |
| printf("ASTC/BC6H half float space error metrics (a piecewise linear approximation of log2 error):\n"); |
| } |
| |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| { |
| const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| |
| if (m_params.m_compute_stats) |
| { |
| image_stats& s = m_stats[slice_index]; |
| |
| if (m_params.m_print_stats) |
| { |
| printf("Slice: %u\n", slice_index); |
| } |
| |
| image_metrics im; |
| |
| if (m_params.m_print_stats) |
| { |
| printf("\nASTC channels:\n"); |
| for (uint32_t i = 0; i < 3; i++) |
| { |
| im.calc_half(m_slice_images_hdr[slice_index], m_decoded_output_textures_astc_hdr_unpacked[slice_index], i, 1, true); |
| |
| printf("%c: ", "RGB"[i]); |
| im.print_hp(); |
| } |
| |
| printf("BC6H channels:\n"); |
| for (uint32_t i = 0; i < 3; i++) |
| { |
| im.calc_half(m_slice_images_hdr[slice_index], m_decoded_output_textures_bc6h_hdr_unpacked[slice_index], i, 1, true); |
| |
| printf("%c: ", "RGB"[i]); |
| im.print_hp(); |
| } |
| } |
| |
| im.calc_half(m_slice_images_hdr[slice_index], m_decoded_output_textures_astc_hdr_unpacked[slice_index], 0, 3, true); |
| s.m_basis_rgb_avg_psnr = (float)im.m_psnr; |
| |
| if (m_params.m_print_stats) |
| { |
| printf("\nASTC RGB: "); |
| im.print_hp(); |
| #if 0 |
| // Validation |
| im.calc_half2(m_slice_images_hdr[slice_index], m_decoded_output_textures_astc_hdr_unpacked[slice_index], 0, 3, true); |
| printf("\nASTC RGB (Alt): "); |
| im.print_hp(); |
| #endif |
| } |
| |
| im.calc_half(m_slice_images_hdr[slice_index], m_decoded_output_textures_bc6h_hdr_unpacked[slice_index], 0, 3, true); |
| s.m_basis_rgb_avg_bc6h_psnr = (float)im.m_psnr; |
| |
| if (m_params.m_print_stats) |
| { |
| printf("BC6H RGB: "); |
| im.print_hp(); |
| printf("\n"); |
| } |
| } |
| |
| if (m_params.m_debug_images) |
| { |
| std::string out_basename; |
| if (m_params.m_out_filename.size()) |
| string_get_filename(m_params.m_out_filename.c_str(), out_basename); |
| else if (m_params.m_source_filenames.size()) |
| string_get_filename(m_params.m_source_filenames[slice_desc.m_source_file_index].c_str(), out_basename); |
| |
| string_remove_extension(out_basename); |
| out_basename = "basis_debug_" + out_basename + string_format("_slice_%u", slice_index); |
| |
| // Write BC6H .DDS file. |
| { |
| gpu_image bc6h_tex(m_decoded_output_textures[slice_index]); |
| bc6h_tex.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); |
| |
| std::string filename(out_basename + "_bc6h.dds"); |
| write_compressed_texture_file(filename.c_str(), bc6h_tex, true); |
| printf("Wrote .DDS file %s\n", filename.c_str()); |
| } |
| |
| // Write ASTC .KTX/.astc files. ("astcenc -dh input.astc output.exr" to decode the astc file.) |
| { |
| gpu_image astc_tex(m_decoded_output_textures_astc_hdr[slice_index]); |
| astc_tex.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); |
| |
| std::string filename1(out_basename + "_astc.astc"); |
| write_astc_file(filename1.c_str(), astc_tex.get_ptr(), 4, 4, slice_desc.m_orig_width, slice_desc.m_orig_height); |
| printf("Wrote .ASTC file %s\n", filename1.c_str()); |
| |
| std::string filename2(out_basename + "_astc.ktx"); |
| write_compressed_texture_file(filename2.c_str(), astc_tex, true); |
| printf("Wrote .KTX file %s\n", filename2.c_str()); |
| } |
| |
| // Write unpacked ASTC image to .EXR |
| { |
| imagef astc_img(m_decoded_output_textures_astc_hdr_unpacked[slice_index]); |
| astc_img.resize(slice_desc.m_orig_width, slice_desc.m_orig_height); |
| |
| std::string filename(out_basename + "_unpacked_astc.exr"); |
| write_exr(filename.c_str(), astc_img, 3, 0); |
| printf("Wrote .EXR file %s\n", filename.c_str()); |
| } |
| |
| // Write unpacked BC6H image to .EXR |
| { |
| imagef bc6h_img(m_decoded_output_textures_bc6h_hdr_unpacked[slice_index]); |
| bc6h_img.resize(slice_desc.m_orig_width, slice_desc.m_orig_height); |
| |
| std::string filename(out_basename + "_unpacked_bc6h.exr"); |
| write_exr(filename.c_str(), bc6h_img, 3, 0); |
| printf("Wrote .EXR file %s\n", filename.c_str()); |
| } |
| |
| // Write tonemapped/srgb images |
| write_hdr_debug_images((out_basename + "_source").c_str(), m_slice_images_hdr[slice_index], slice_desc.m_orig_width, slice_desc.m_orig_height); |
| write_hdr_debug_images((out_basename + "_unpacked_astc").c_str(), m_decoded_output_textures_astc_hdr_unpacked[slice_index], slice_desc.m_orig_width, slice_desc.m_orig_height); |
| write_hdr_debug_images((out_basename + "_unpacked_bc6h").c_str(), m_decoded_output_textures_bc6h_hdr_unpacked[slice_index], slice_desc.m_orig_width, slice_desc.m_orig_height); |
| } |
| } |
| } |
| else |
| { |
| for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) |
| { |
| const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; |
| |
| if (m_params.m_compute_stats) |
| { |
| if (m_params.m_print_stats) |
| printf("Slice: %u\n", slice_index); |
| |
| image_stats& s = m_stats[slice_index]; |
| |
| image_metrics em; |
| |
| // ---- .basis stats |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 3); |
| if (m_params.m_print_stats) |
| em.print(".basis RGB Avg: "); |
| s.m_basis_rgb_avg_psnr = (float)em.m_psnr; |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 4); |
| if (m_params.m_print_stats) |
| em.print(".basis RGBA Avg: "); |
| s.m_basis_rgba_avg_psnr = (float)em.m_psnr; |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 1); |
| if (m_params.m_print_stats) |
| em.print(".basis R Avg: "); |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 1, 1); |
| if (m_params.m_print_stats) |
| em.print(".basis G Avg: "); |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 2, 1); |
| if (m_params.m_print_stats) |
| em.print(".basis B Avg: "); |
| |
| if (m_params.m_uastc) |
| { |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 3, 1); |
| if (m_params.m_print_stats) |
| em.print(".basis A Avg: "); |
| |
| s.m_basis_a_avg_psnr = (float)em.m_psnr; |
| } |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 0); |
| if (m_params.m_print_stats) |
| em.print(".basis 709 Luma: "); |
| s.m_basis_luma_709_psnr = static_cast<float>(em.m_psnr); |
| s.m_basis_luma_709_ssim = static_cast<float>(em.m_ssim); |
| |
| em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 0, true, true); |
| if (m_params.m_print_stats) |
| em.print(".basis 601 Luma: "); |
| s.m_basis_luma_601_psnr = static_cast<float>(em.m_psnr); |
| |
| if (m_slice_descs.size() == 1) |
| { |
| const uint32_t output_size = comp_size ? (uint32_t)comp_size : (uint32_t)comp_data.size(); |
| if (m_params.m_print_stats) |
| { |
| debug_printf(".basis RGB PSNR per bit/texel*10000: %3.3f\n", 10000.0f * s.m_basis_rgb_avg_psnr / ((output_size * 8.0f) / (slice_desc.m_orig_width * slice_desc.m_orig_height))); |
| debug_printf(".basis Luma 709 PSNR per bit/texel*10000: %3.3f\n", 10000.0f * s.m_basis_luma_709_psnr / ((output_size * 8.0f) / (slice_desc.m_orig_width * slice_desc.m_orig_height))); |
| } |
| } |
| |
| if (m_decoded_output_textures_unpacked_bc7[slice_index].get_width()) |
| { |
| // ---- BC7 stats |
| |