diff options
Diffstat (limited to 'thirdparty/basis_universal/encoder/basisu_comp.cpp')
| -rw-r--r-- | thirdparty/basis_universal/encoder/basisu_comp.cpp | 2028 |
1 files changed, 1686 insertions, 342 deletions
diff --git a/thirdparty/basis_universal/encoder/basisu_comp.cpp b/thirdparty/basis_universal/encoder/basisu_comp.cpp index 4e69e9e2ee..81813257cd 100644 --- a/thirdparty/basis_universal/encoder/basisu_comp.cpp +++ b/thirdparty/basis_universal/encoder/basisu_comp.cpp @@ -1,5 +1,5 @@ // basisu_comp.cpp -// Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. +// 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. @@ -16,6 +16,9 @@ #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 @@ -23,6 +26,8 @@ #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 @@ -34,7 +39,7 @@ // 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 the validator bug. +// 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; @@ -46,27 +51,143 @@ using namespace buminiz; namespace basisu { - basis_compressor::basis_compressor() : - m_pOpenCL_context(nullptr), + 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) + 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; - } - } + 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) { @@ -85,7 +206,12 @@ namespace basisu } 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"); @@ -95,8 +221,10 @@ namespace basisu #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 images: %u, source filenames: %u, source alpha filenames: %i, Source mipmap images: %u\n", - m_params.m_source_images.size(), m_params.m_source_filenames.size(), m_params.m_source_alpha_filenames.size(), m_params.m_source_mipmap_images.size()); + 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()) { @@ -106,6 +234,15 @@ namespace basisu 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); @@ -117,7 +254,7 @@ namespace basisu 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_files); + 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); @@ -146,6 +283,7 @@ namespace basisu 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); @@ -185,6 +323,9 @@ namespace basisu } 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 @@ -192,19 +333,9 @@ namespace basisu #undef PRINT_FLOAT_VALUE } - if ((m_params.m_read_source_images) && (!m_params.m_source_filenames.size())) - { - assert(0); + if (!sanity_check_input_params()) return false; - } - - if ((m_params.m_compute_stats) && (!m_params.m_validate_output_data)) - { - m_params.m_validate_output_data = true; - - debug_printf("Note: m_compute_stats is true, so forcing m_validate_output_data to true as well\n"); - } - + if ((m_params.m_use_opencl) && opencl_is_available() && !m_pOpenCL_context && !m_opencl_failed) { m_pOpenCL_context = opencl_create_context(); @@ -219,6 +350,9 @@ namespace basisu { debug_printf("basis_compressor::process\n"); + if (!read_dds_source_images()) + return cECFailedReadingSourceImages; + if (!read_source_images()) return cECFailedReadingSourceImages; @@ -228,20 +362,38 @@ namespace basisu 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_uastc) + if (m_params.m_hdr) + { + // UASTC HDR + 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 + 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 + printf("Mode: ETC1S Quality %i, Level %i\n", m_params.m_quality_level, (int)m_params.m_compression_level); + if (!process_frontend()) return cECFailedFrontEnd; @@ -254,7 +406,7 @@ namespace basisu if (!create_basis_file_and_transcode()) return cECFailedCreateBasisFile; - + if (m_params.m_create_ktx2_file) { if (!create_ktx2_file()) @@ -267,6 +419,309 @@ namespace basisu 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"); @@ -328,7 +783,7 @@ namespace basisu total_blocks_processed++; uint32_t val = total_blocks_processed; - if ((val & 16383) == 16383) + 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); } @@ -374,6 +829,57 @@ namespace basisu 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"); @@ -463,17 +969,224 @@ namespace basisu 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() : (uint32_t)m_params.m_source_images.size(); + 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; @@ -481,106 +1194,196 @@ namespace basisu 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 = ""; + 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 (!load_image(pSource_filename, file_image)) + if (m_params.m_hdr) { - error_printf("Failed reading source image: %s\n", pSource_filename); - return false; + 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, file_image.get_width(), file_image.get_height()); + printf("Read source image \"%s\", %ux%u\n", pSource_filename, width, height); } - // 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())) + if (m_params.m_hdr) + { + clean_hdr_image(file_image_hdr); + } + else { - const char *pSource_alpha_image = m_params.m_source_alpha_filenames[source_file_index].c_str(); + // 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; + image alpha_data; - if (!load_image(pSource_alpha_image, alpha_data)) - { - error_printf("Failed reading source image: %s\n", pSource_alpha_image); - return false; - } + 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()); + printf("Read source alpha image \"%s\", %ux%u\n", pSource_alpha_image, alpha_data.get_width(), alpha_data.get_height()); - alpha_data.crop(file_image.get_width(), file_image.get_height()); + alpha_data.crop(width, height); - for (uint32_t y = 0; y < file_image.get_height(); y++) - for (uint32_t x = 0; x < file_image.get_width(); x++) - file_image(x, y).a = (uint8_t)alpha_data(x, y).get_709_luma(); + 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 { - file_image = m_params.m_source_images[source_file_index]; + 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_renormalize) - file_image.renormalize_normal_map(); + 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) { - // 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++) + 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++) { - 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]]); + 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]]); + } } - alpha_swizzled = m_params.m_swizzle[3] != 3; + } } - + bool has_alpha = false; - 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; + 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); + } - debug_printf("Source image index %u filename %s %ux%u has alpha: %u\n", source_file_index, pSource_filename, file_image.get_width(), file_image.get_height(), has_alpha); - if (m_params.m_y_flip) - file_image.flip_y(); + { + if (m_params.m_hdr) + file_image_hdr.flip_y(); + else + file_image.flip_y(); + } #if DEBUG_EXTRACT_SINGLE_BLOCK - image block_image(4, 4); const uint32_t block_x = 0; const uint32_t block_y = 0; - block_image.blit(block_x * 4, block_y * 4, 4, 4, 0, 0, file_image, 0); - file_image = block_image; + + 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 - file_image.resize(64, 64); + 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) + 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); @@ -588,129 +1391,225 @@ namespace basisu 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. - image temp_img(new_width, new_height); - image_resample(file_image, temp_img, m_params.m_perceptual, "box"); // "kaiser"); - temp_img.swap(file_image); + 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) { - 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); + // 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); + 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. - image temp_img(new_width, new_height); - image_resample(file_image, temp_img, m_params.m_perceptual, "box"); // "kaiser"); - temp_img.swap(file_image); + 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); + } } - if ((!file_image.get_width()) || (!file_image.get_height())) + 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 ((file_image.get_width() > BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION) || (file_image.get_height() > BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION)) + 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; } - source_images.enlarge(1)->swap(file_image); + 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_source_mipmap_images.size()) + if (m_params.m_hdr) { - // 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())) + if (m_params.m_source_mipmap_images_hdr.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; + // 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; + } } - - // Check if any of the user-supplied mipmap levels has alpha. - // We're assuming the user has already preswizzled their mipmap source images. - if (!m_any_source_image_has_alpha) + } + else + { + if (m_params.m_source_mipmap_images.size()) { - for (uint32_t source_file_index = 0; source_file_index < total_source_files; source_file_index++) + // 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())) { - 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]; + 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; + } - if (mip_img.has_alpha()) + // 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++) { - m_any_source_image_has_alpha = true; - break; + 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; + 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]; - - // Now, for each source image, create the slices corresponding to that image. + basisu::vector<image> slices; + basisu::vector<imagef> slices_hdr; slices.reserve(32); + slices_hdr.reserve(32); // The first (largest) mipmap level. - image& file_image = source_images[source_file_index]; - + 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. - slices.resize(1); - - if (m_params.m_source_mipmap_images.size()) + 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) + 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); + 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 (!generate_mipmaps(file_image, slices, m_any_source_image_has_alpha)) - return false; + 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. - slices[0].swap(file_image); + if (m_params.m_hdr) + slices_hdr[0].swap(*pFile_image_hdr); + else + slices[0].swap(*pFile_image); - uint_vec mip_indices(slices.size()); - for (uint32_t i = 0; i < slices.size(); i++) + 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_any_source_image_has_alpha) && (!m_params.m_uastc)) + 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; @@ -745,20 +1644,29 @@ namespace basisu mip_indices.swap(new_mip_indices); } - assert(slices.size() == mip_indices.size()); - - for (uint32_t slice_index = 0; slice_index < slices.size(); slice_index++) + 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& slice_image = slices[slice_index]; - const uint32_t orig_width = slice_image.get_width(); - const uint32_t orig_height = slice_image.get_height(); + 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_any_source_image_has_alpha) + if ((!m_params.m_hdr) && (m_any_source_image_has_alpha)) { if (m_params.m_uastc) { - is_alpha_slice = slice_image.has_alpha(); + is_alpha_slice = pSlice_image->has_alpha(); } else { @@ -767,43 +1675,69 @@ namespace basisu } // Enlarge the source image to 4x4 block boundaries, duplicating edge pixels if necessary to avoid introducing extra colors into blocks. - slice_image.crop_dup_borders(slice_image.get_block_width(4) * 4, slice_image.get_block_height(4) * 4); + 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) { - save_png(string_format("basis_debug_source_image_%u_slice_%u.png", source_file_index, slice_index).c_str(), slice_image); + 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_slice_images.size(); + const uint32_t dest_image_index = (m_params.m_hdr ? m_slice_images_hdr.size() : m_slice_images.size()); enlarge_vector(m_stats, 1); - enlarge_vector(m_slice_images, 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, slice_image.get_width(), slice_image.get_height()); - basisu_backend_slice_desc &slice_desc = m_slice_descs[dest_image_index]; + 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; - slice_desc.m_width = slice_image.get_width(); - slice_desc.m_height = slice_image.get_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 = slice_image.get_block_width(4); - slice_desc.m_num_blocks_y = slice_image.get_block_height(4); + 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; @@ -818,8 +1752,11 @@ namespace basisu // Finally, swap in the slice's image to avoid copying it. // NOTE: slice_image is now blank. - m_slice_images[dest_image_index].swap(slice_image); - + 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 @@ -855,7 +1792,7 @@ namespace basisu if (m_params.m_status_output) { - printf("Total basis file slices: %u\n", (uint32_t)m_slice_descs.size()); + printf("Total slices: %u\n", (uint32_t)m_slice_descs.size()); } for (uint32_t i = 0; i < m_slice_descs.size(); i++) @@ -865,11 +1802,17 @@ namespace basisu 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); + 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. @@ -903,6 +1846,7 @@ namespace basisu 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) @@ -924,7 +1868,7 @@ namespace basisu uint32_t total_basis_images = 0; - for (uint32_t slice_index = 0; slice_index < m_slice_images.size(); slice_index++) + 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]; @@ -945,7 +1889,7 @@ namespace basisu uint_vec image_mipmap_levels(total_basis_images); int width = -1, height = -1; - for (uint32_t slice_index = 0; slice_index < m_slice_images.size(); slice_index++) + 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]; @@ -982,20 +1926,52 @@ namespace basisu { debug_printf("basis_compressor::extract_source_blocks\n"); - m_source_blocks.resize(m_total_blocks); + 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_slice_images.size(); slice_index++) + 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& source_image = m_slice_images[slice_index]; + 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++) - source_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); + { + 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; @@ -1304,6 +2280,8 @@ namespace basisu 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]; @@ -1335,10 +2313,21 @@ namespace basisu } m_decoded_output_textures.resize(m_slice_descs.size()); - 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()); + 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) @@ -1360,12 +2349,16 @@ namespace basisu 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(m_params.m_uastc ? texture_format::cUASTC4x4 : texture_format::cETC1, m_slice_descs[i].m_width, m_slice_descs[i].m_height); + decoded_texture.init( + tex_format, + m_slice_descs[i].m_width, m_slice_descs[i].m_height); tm.start(); - - basist::block_format format = m_params.m_uastc ? basist::block_format::cUASTC_4x4 : basist::block_format::cETC1; + uint32_t bytes_per_block = m_params.m_uastc ? 16 : 8; if (!decoder.transcode_slice(&comp_data[0], (uint32_t)comp_data.size(), i, @@ -1391,43 +2384,87 @@ namespace basisu m_decoded_output_textures[i] = decoded_texture; } - double total_time_bc7 = 0; + double total_alt_transcode_time = 0; + tm.start(); - 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)) + 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::cBC7, m_slice_descs[i].m_width, m_slice_descs[i].m_height); + 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<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)) + 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 BC7 on slice %u!\n", i); + error_printf("Transcoding failed to ASTC HDR on slice %u!\n", i); return false; } - - total_time_bc7 += tm.get_elapsed_secs(); - - m_decoded_output_textures_bc7[i] = decoded_texture; + + 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++) { - m_decoded_output_textures[i].unpack(m_decoded_output_textures_unpacked[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()) - m_decoded_output_textures_bc7[i].unpack(m_decoded_output_textures_unpacked_bc7[i]); + 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_uastc ? "ASTC" : "ETC1", total_time_etc1s_or_astc * 1000.0f, total_orig_pixels / total_time_etc1s_or_astc); + 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_time_bc7 != 0) - debug_printf("Transcoded to BC7 in %3.3fms, %f texels/sec\n", total_time_bc7 * 1000.0f, total_orig_pixels / total_time_bc7); + 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++) { @@ -1438,17 +2475,82 @@ namespace basisu 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_files) + if (m_params.m_write_output_basis_or_ktx2_files) { const std::string& output_filename = m_params.m_out_filename; @@ -1458,7 +2560,7 @@ namespace basisu return false; } - if (m_params.m_status_output) + //if (m_params.m_status_output) { printf("Wrote output .basis/.ktx2 file \"%s\"\n", output_filename.c_str()); } @@ -1485,7 +2587,7 @@ namespace basisu m_basis_bits_per_texel = comp_size * 8.0f / total_texels; - debug_printf(".basis file size: %u, LZ compressed file size: %u, %3.2f bits/texel\n", + 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); @@ -1495,191 +2597,324 @@ namespace basisu if (m_params.m_validate_output_data) { - for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) + if (m_params.m_hdr) { - const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; + if (m_params.m_print_stats) + { + printf("ASTC/BC6H half float space error metrics (a piecewise linear approximation of log2 error):\n"); + } - if (m_params.m_compute_stats) + for (uint32_t slice_index = 0; slice_index < m_slice_descs.size(); slice_index++) { - if (m_params.m_print_stats) - printf("Slice: %u\n", slice_index); + const basisu_backend_slice_desc& slice_desc = m_slice_descs[slice_index]; - image_stats& s = m_stats[slice_index]; + if (m_params.m_compute_stats) + { + image_stats& s = m_stats[slice_index]; - // TODO: We used to output SSIM (during heavy encoder development), but this slowed down compression too much. We'll be adding it back. + if (m_params.m_print_stats) + { + printf("Slice: %u\n", slice_index); + } - image_metrics em; + image_metrics im; - // ---- .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 = em.m_psnr; + 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); - 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 = em.m_psnr; + printf("%c: ", "RGB"[i]); + im.print_hp(); + } - 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: "); + 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); - 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: "); + printf("%c: ", "RGB"[i]); + im.print_hp(); + } + } - 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: "); + 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_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: "); + { + 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 + } - s.m_basis_a_avg_psnr = em.m_psnr; + 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); - 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); + string_remove_extension(out_basename); + out_basename = "basis_debug_" + out_basename + string_format("_slice_%u", slice_index); - 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); + // 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()); + } - 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) + // 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 { - 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))); + 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_decoded_output_textures_unpacked_bc7[slice_index].get_width()) + if (m_params.m_compute_stats) { - // ---- BC7 stats - em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 3); if (m_params.m_print_stats) - em.print("BC7 RGB Avg: "); - s.m_bc7_rgb_avg_psnr = em.m_psnr; + printf("Slice: %u\n", slice_index); + + image_stats& s = m_stats[slice_index]; + + image_metrics em; - em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 4); + // ---- .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("BC7 RGBA Avg: "); - s.m_bc7_rgba_avg_psnr = em.m_psnr; + 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_bc7[slice_index], 0, 1); + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 4); if (m_params.m_print_stats) - em.print("BC7 R Avg: "); + 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_bc7[slice_index], 1, 1); + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 1); if (m_params.m_print_stats) - em.print("BC7 G Avg: "); + em.print(".basis R Avg: "); - em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 2, 1); + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 1, 1); if (m_params.m_print_stats) - em.print("BC7 B Avg: "); + 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_bc7[slice_index], 3, 1); + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 3, 1); if (m_params.m_print_stats) - em.print("BC7 A Avg: "); + em.print(".basis A Avg: "); - s.m_bc7_a_avg_psnr = em.m_psnr; + s.m_basis_a_avg_psnr = (float)em.m_psnr; } - em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 0); + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked[slice_index], 0, 0); if (m_params.m_print_stats) - em.print("BC7 709 Luma: "); - s.m_bc7_luma_709_psnr = static_cast<float>(em.m_psnr); - s.m_bc7_luma_709_ssim = static_cast<float>(em.m_ssim); + 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_bc7[slice_index], 0, 0, true, true); + 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("BC7 601 Luma: "); - s.m_bc7_luma_601_psnr = static_cast<float>(em.m_psnr); - } + em.print(".basis 601 Luma: "); + s.m_basis_luma_601_psnr = static_cast<float>(em.m_psnr); - if (!m_params.m_uastc) - { - // ---- Nearly best possible ETC1S stats - em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 3); - if (m_params.m_print_stats) - em.print("Unquantized ETC1S RGB Avg: "); - s.m_best_etc1s_rgb_avg_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))); + } + } - em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 0); - if (m_params.m_print_stats) - em.print("Unquantized ETC1S 709 Luma: "); - s.m_best_etc1s_luma_709_psnr = static_cast<float>(em.m_psnr); - s.m_best_etc1s_luma_709_ssim = static_cast<float>(em.m_ssim); + if (m_decoded_output_textures_unpacked_bc7[slice_index].get_width()) + { + // ---- BC7 stats + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 3); + //if (m_params.m_print_stats) + // em.print("BC7 RGB Avg: "); + s.m_bc7_rgb_avg_psnr = (float)em.m_psnr; + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 4); + //if (m_params.m_print_stats) + // em.print("BC7 RGBA Avg: "); + s.m_bc7_rgba_avg_psnr = (float)em.m_psnr; + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 1); + //if (m_params.m_print_stats) + // em.print("BC7 R Avg: "); + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 1, 1); + //if (m_params.m_print_stats) + // em.print("BC7 G Avg: "); + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 2, 1); + //if (m_params.m_print_stats) + // em.print("BC7 B Avg: "); + + if (m_params.m_uastc) + { + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 3, 1); + //if (m_params.m_print_stats) + // em.print("BC7 A Avg: "); - em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 0, true, true); - if (m_params.m_print_stats) - em.print("Unquantized ETC1S 601 Luma: "); - s.m_best_etc1s_luma_601_psnr = static_cast<float>(em.m_psnr); + s.m_bc7_a_avg_psnr = (float)em.m_psnr; + } + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 0); + //if (m_params.m_print_stats) + // em.print("BC7 709 Luma: "); + s.m_bc7_luma_709_psnr = static_cast<float>(em.m_psnr); + s.m_bc7_luma_709_ssim = static_cast<float>(em.m_ssim); + + em.calc(m_slice_images[slice_index], m_decoded_output_textures_unpacked_bc7[slice_index], 0, 0, true, true); + //if (m_params.m_print_stats) + // em.print("BC7 601 Luma: "); + s.m_bc7_luma_601_psnr = static_cast<float>(em.m_psnr); + } + + if (!m_params.m_uastc) + { + // ---- Nearly best possible ETC1S stats + em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 3); + //if (m_params.m_print_stats) + // em.print("Unquantized ETC1S RGB Avg: "); + s.m_best_etc1s_rgb_avg_psnr = static_cast<float>(em.m_psnr); + + em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 0); + //if (m_params.m_print_stats) + // em.print("Unquantized ETC1S 709 Luma: "); + s.m_best_etc1s_luma_709_psnr = static_cast<float>(em.m_psnr); + s.m_best_etc1s_luma_709_ssim = static_cast<float>(em.m_ssim); + + em.calc(m_slice_images[slice_index], m_best_etc1s_images_unpacked[slice_index], 0, 0, true, true); + //if (m_params.m_print_stats) + // em.print("Unquantized ETC1S 601 Luma: "); + s.m_best_etc1s_luma_601_psnr = static_cast<float>(em.m_psnr); + } } - } - 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); + 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); + string_remove_extension(out_basename); + out_basename = "basis_debug_" + out_basename + string_format("_slice_%u", slice_index); - if ((!m_params.m_uastc) && (m_frontend.get_params().m_debug_images)) - { - // Write "best" ETC1S debug images - if (!m_params.m_uastc) + if ((!m_params.m_uastc) && (m_frontend.get_params().m_debug_images)) { - gpu_image best_etc1s_gpu_image(m_best_etc1s_images[slice_index]); - best_etc1s_gpu_image.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); - write_compressed_texture_file((out_basename + "_best_etc1s.ktx").c_str(), best_etc1s_gpu_image); + // Write "best" ETC1S debug images + if (!m_params.m_uastc) + { + gpu_image best_etc1s_gpu_image(m_best_etc1s_images[slice_index]); + best_etc1s_gpu_image.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); + write_compressed_texture_file((out_basename + "_best_etc1s.ktx").c_str(), best_etc1s_gpu_image, true); - image best_etc1s_unpacked; - best_etc1s_gpu_image.unpack(best_etc1s_unpacked); - save_png(out_basename + "_best_etc1s.png", best_etc1s_unpacked); + image best_etc1s_unpacked; + best_etc1s_gpu_image.unpack(best_etc1s_unpacked); + save_png(out_basename + "_best_etc1s.png", best_etc1s_unpacked); + } } - } - if (m_params.m_debug_images) - { - // Write decoded ETC1S/ASTC debug images + if (m_params.m_debug_images) { - gpu_image decoded_etc1s_or_astc(m_decoded_output_textures[slice_index]); - decoded_etc1s_or_astc.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); - write_compressed_texture_file((out_basename + "_transcoded_etc1s_or_astc.ktx").c_str(), decoded_etc1s_or_astc); + // Write decoded ETC1S/ASTC debug images + { + gpu_image decoded_etc1s_or_astc(m_decoded_output_textures[slice_index]); + decoded_etc1s_or_astc.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); + write_compressed_texture_file((out_basename + "_transcoded_etc1s_or_astc.ktx").c_str(), decoded_etc1s_or_astc, true); - image temp(m_decoded_output_textures_unpacked[slice_index]); - temp.crop(slice_desc.m_orig_width, slice_desc.m_orig_height); - save_png(out_basename + "_transcoded_etc1s_or_astc.png", temp); - } + image temp(m_decoded_output_textures_unpacked[slice_index]); + temp.crop(slice_desc.m_orig_width, slice_desc.m_orig_height); + save_png(out_basename + "_transcoded_etc1s_or_astc.png", temp); + } - // Write decoded BC7 debug images - if (m_decoded_output_textures_bc7[slice_index].get_pixel_width()) - { - gpu_image decoded_bc7(m_decoded_output_textures_bc7[slice_index]); - decoded_bc7.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); - write_compressed_texture_file((out_basename + "_transcoded_bc7.ktx").c_str(), decoded_bc7); + // Write decoded BC7 debug images + if (m_decoded_output_textures_bc7[slice_index].get_pixel_width()) + { + gpu_image decoded_bc7(m_decoded_output_textures_bc7[slice_index]); + decoded_bc7.override_dimensions(slice_desc.m_orig_width, slice_desc.m_orig_height); + write_compressed_texture_file((out_basename + "_transcoded_bc7.ktx").c_str(), decoded_bc7, true); - image temp(m_decoded_output_textures_unpacked_bc7[slice_index]); - temp.crop(slice_desc.m_orig_width, slice_desc.m_orig_height); - save_png(out_basename + "_transcoded_bc7.png", temp); + image temp(m_decoded_output_textures_unpacked_bc7[slice_index]); + temp.crop(slice_desc.m_orig_width, slice_desc.m_orig_height); + save_png(out_basename + "_transcoded_bc7.png", temp); + } } } - } + } // if (m_params.m_hdr) + } // if (m_params.m_validate_output_data) return true; @@ -1727,10 +2962,27 @@ namespace basisu } static uint8_t g_ktx2_etc1s_nonalpha_dfd[44] = { 0x2C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x28,0x0,0xA3,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3F,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; - static uint8_t g_ktx2_etc1s_alpha_dfd[60] = { 0x3C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x38,0x0,0xA3,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3F,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x40,0x0,0x3F,0xF,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; + static uint8_t g_ktx2_etc1s_alpha_dfd[60] = { 0x3C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x38,0x0,0xA3,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3F,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x40,0x0,0x3F,0xF,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; + static uint8_t g_ktx2_uastc_nonalpha_dfd[44] = { 0x2C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x28,0x0,0xA6,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7F,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; - static uint8_t g_ktx2_uastc_alpha_dfd[44] = { 0x2C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x28,0x0,0xA6,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7F,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; - + static uint8_t g_ktx2_uastc_alpha_dfd[44] = { 0x2C,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x28,0x0,0xA6,0x1,0x2,0x0,0x3,0x3,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7F,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xFF,0xFF,0xFF,0xFF }; + + // HDR TODO - what is the best Khronos DFD to use for UASTC HDR? + static uint8_t g_ktx2_uastc_hdr_nonalpha_dfd[44] = + { + 0x2C,0x0,0x0,0x0, // 0 totalSize + 0x0,0x0,0x0,0x0, // 1 descriptorType/vendorId + 0x2,0x0,0x28,0x0, // 2 descriptorBlockSize/versionNumber + 0xA7,0x1,0x1,0x0, // 3 flags, transferFunction, colorPrimaries, colorModel + 0x3,0x3,0x0,0x0, // 4 texelBlockDimension0-texelBlockDimension3 + 0x10,0x0,0x0,0x0, // 5 bytesPlane0-bytesPlane3 + 0x0,0x0,0x0,0x0, // 6 bytesPlane4-bytesPlane7 + 0x0,0x0,0x7F,0x80, // 7 bitLength/bitOffset/channelType and Qualifer flags (KHR_DF_SAMPLE_DATATYPE_FLOAT etc.) + 0x0,0x0,0x0,0x0, // 8 samplePosition0-samplePosition3 + 0x0,0x0,0x0,0x0, // 9 sampleLower (0.0) + 0x00, 0x00, 0x80, 0x3F // 10 sampleHigher (1.0) + }; + void basis_compressor::get_dfd(uint8_vec &dfd, const basist::ktx2_header &header) { const uint8_t* pDFD; @@ -1738,7 +2990,12 @@ namespace basisu if (m_params.m_uastc) { - if (m_any_source_image_has_alpha) + if (m_params.m_hdr) + { + pDFD = g_ktx2_uastc_hdr_nonalpha_dfd; + dfd_len = sizeof(g_ktx2_uastc_hdr_nonalpha_dfd); + } + else if (m_any_source_image_has_alpha) { pDFD = g_ktx2_uastc_alpha_dfd; dfd_len = sizeof(g_ktx2_uastc_alpha_dfd); @@ -1772,10 +3029,18 @@ namespace basisu dfd_bits &= ~(0xFF << 16); - if (m_params.m_ktx2_srgb_transfer_func) - dfd_bits |= (basist::KTX2_KHR_DF_TRANSFER_SRGB << 16); - else + if (m_params.m_hdr) + { + // TODO: In HDR mode, always write linear for now. dfd_bits |= (basist::KTX2_KHR_DF_TRANSFER_LINEAR << 16); + } + else + { + if (m_params.m_ktx2_srgb_transfer_func) + dfd_bits |= (basist::KTX2_KHR_DF_TRANSFER_SRGB << 16); + else + dfd_bits |= (basist::KTX2_KHR_DF_TRANSFER_LINEAR << 16); + } basisu::write_le_dword(dfd.data() + 3 * sizeof(uint32_t), dfd_bits); @@ -1850,7 +3115,12 @@ namespace basisu header.m_pixel_width = base_width; header.m_pixel_height = base_height; header.m_face_count = total_faces; - header.m_vk_format = basist::KTX2_VK_FORMAT_UNDEFINED; + + if (m_params.m_hdr) + header.m_vk_format = basist::KTX2_FORMAT_UASTC_4x4_SFLOAT_BLOCK; + else + header.m_vk_format = basist::KTX2_VK_FORMAT_UNDEFINED; + header.m_type_size = 1; header.m_level_count = total_levels; header.m_layer_count = (total_layers > 1) ? total_layers : 0; @@ -2061,7 +3331,8 @@ namespace basisu if (bytes_needed_to_pad < 6) bytes_needed_to_pad += 16; - printf("WARNING: Due to a KTX2 validator bug related to mipPadding, we must insert a dummy key into the KTX2 file of %u bytes\n", bytes_needed_to_pad); + // Just add the padding. It's likely not necessary anymore, but can't really hurt. + //printf("WARNING: Due to a KTX2 validator bug related to mipPadding, we must insert a dummy key into the KTX2 file of %u bytes\n", bytes_needed_to_pad); // We're not good - need to add a dummy key large enough to force file alignment so the mip level array gets aligned. // We can't just add some bytes before the mip level array because ktx2check will see that as extra data in the file that shouldn't be there in ktxValidator::validateDataSize(). @@ -2258,18 +3529,34 @@ namespace basisu return result; } - void* basis_compress( - const basisu::vector<image>& source_images, + static void* basis_compress( + const basisu::vector<image> *pSource_images, + const basisu::vector<imagef> *pSource_images_hdr, uint32_t flags_and_quality, float uastc_rdo_quality, size_t* pSize, image_stats* pStats) { + assert((pSource_images != nullptr) || (pSource_images_hdr != nullptr)); + assert(!((pSource_images != nullptr) && (pSource_images_hdr != nullptr))); + // Check input parameters - if ((!source_images.size()) || (!pSize)) + if (pSource_images) { - error_printf("basis_compress: Invalid parameter\n"); - assert(0); - return nullptr; + if ((!pSource_images->size()) || (!pSize)) + { + error_printf("basis_compress: Invalid parameter\n"); + assert(0); + return nullptr; + } + } + else + { + if ((!pSource_images_hdr->size()) || (!pSize)) + { + error_printf("basis_compress: Invalid parameter\n"); + assert(0); + return nullptr; + } } *pSize = 0; @@ -2287,40 +3574,70 @@ namespace basisu comp_params.m_y_flip = (flags_and_quality & cFlagYFlip) != 0; comp_params.m_debug = (flags_and_quality & cFlagDebug) != 0; - + comp_params.m_debug_images = (flags_and_quality & cFlagDebugImages) != 0; + // Copy the largest mipmap level - comp_params.m_source_images.resize(1); - comp_params.m_source_images[0] = source_images[0]; + if (pSource_images) + { + comp_params.m_source_images.resize(1); + comp_params.m_source_images[0] = (*pSource_images)[0]; + + // Copy the smaller mipmap levels, if any + if (pSource_images->size() > 1) + { + comp_params.m_source_mipmap_images.resize(1); + comp_params.m_source_mipmap_images[0].resize(pSource_images->size() - 1); - // Copy the smaller mipmap levels, if any - if (source_images.size() > 1) + for (uint32_t i = 1; i < pSource_images->size(); i++) + comp_params.m_source_mipmap_images[0][i - 1] = (*pSource_images)[i]; + } + } + else { - comp_params.m_source_mipmap_images.resize(1); - comp_params.m_source_mipmap_images[0].resize(source_images.size() - 1); + comp_params.m_source_images_hdr.resize(1); + comp_params.m_source_images_hdr[0] = (*pSource_images_hdr)[0]; - for (uint32_t i = 1; i < source_images.size(); i++) - comp_params.m_source_mipmap_images[0][i - 1] = source_images[i]; + // Copy the smaller mipmap levels, if any + if (pSource_images_hdr->size() > 1) + { + comp_params.m_source_mipmap_images_hdr.resize(1); + comp_params.m_source_mipmap_images_hdr[0].resize(pSource_images_hdr->size() - 1); + + for (uint32_t i = 1; i < pSource_images->size(); i++) + comp_params.m_source_mipmap_images_hdr[0][i - 1] = (*pSource_images_hdr)[i]; + } } comp_params.m_multithreading = (flags_and_quality & cFlagThreaded) != 0; comp_params.m_use_opencl = (flags_and_quality & cFlagUseOpenCL) != 0; - comp_params.m_write_output_basis_files = false; + comp_params.m_write_output_basis_or_ktx2_files = false; comp_params.m_perceptual = (flags_and_quality & cFlagSRGB) != 0; comp_params.m_mip_srgb = comp_params.m_perceptual; comp_params.m_mip_gen = (flags_and_quality & (cFlagGenMipsWrap | cFlagGenMipsClamp)) != 0; comp_params.m_mip_wrapping = (flags_and_quality & cFlagGenMipsWrap) != 0; - comp_params.m_uastc = (flags_and_quality & cFlagUASTC) != 0; - if (comp_params.m_uastc) + if ((pSource_images_hdr) || (flags_and_quality & cFlagHDR)) { - comp_params.m_pack_uastc_flags = flags_and_quality & cPackUASTCLevelMask; - comp_params.m_rdo_uastc = (flags_and_quality & cFlagUASTCRDO) != 0; - comp_params.m_rdo_uastc_quality_scalar = uastc_rdo_quality; + // In UASTC HDR mode, the compressor will jam this to true anyway. + // And there's no need to set UASTC LDR or ETC1S options. + comp_params.m_uastc = true; } else - comp_params.m_quality_level = basisu::maximum<uint32_t>(1, flags_and_quality & 255); + { + comp_params.m_uastc = (flags_and_quality & cFlagUASTC) != 0; + if (comp_params.m_uastc) + { + comp_params.m_pack_uastc_flags = flags_and_quality & cPackUASTCLevelMask; + comp_params.m_rdo_uastc = (flags_and_quality & cFlagUASTCRDO) != 0; + comp_params.m_rdo_uastc_quality_scalar = uastc_rdo_quality; + } + else + { + comp_params.m_quality_level = basisu::maximum<uint32_t>(1, flags_and_quality & 255); + } + } comp_params.m_create_ktx2_file = (flags_and_quality & cFlagKTX2) != 0; @@ -2337,6 +3654,15 @@ namespace basisu comp_params.m_print_stats = (flags_and_quality & cFlagPrintStats) != 0; comp_params.m_status_output = (flags_and_quality & cFlagPrintStatus) != 0; + if ((flags_and_quality & cFlagHDR) || (pSource_images_hdr)) + { + comp_params.m_hdr = true; + comp_params.m_uastc_hdr_options.set_quality_level(flags_and_quality & cPackUASTCLevelMask); + } + + if (flags_and_quality & cFlagHDRLDRImageSRGBToLinearConversion) + comp_params.m_hdr_ldr_srgb_to_linear_conversion = true; + // Create the compressor, initialize it, and process the input basis_compressor comp; if (!comp.init(comp_params)) @@ -2381,6 +3707,24 @@ namespace basisu } void* basis_compress( + const basisu::vector<image>& source_images, + uint32_t flags_and_quality, float uastc_rdo_quality, + size_t* pSize, + image_stats* pStats) + { + return basis_compress(&source_images, nullptr, flags_and_quality, uastc_rdo_quality, pSize, pStats); + } + + void* basis_compress( + const basisu::vector<imagef>& source_images_hdr, + uint32_t flags_and_quality, + size_t* pSize, + image_stats* pStats) + { + return basis_compress(nullptr, &source_images_hdr, flags_and_quality, 0.0f, pSize, pStats); + } + + void* basis_compress( const uint8_t* pImageRGBA, uint32_t width, uint32_t height, uint32_t pitch_in_pixels, uint32_t flags_and_quality, float uastc_rdo_quality, size_t* pSize, |