basisu_frontend.cpp | Explore in Territory

// basisu_frontend.cpp
// Copyright (C) 2019-2024 Binomial LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// TODO: 
// This code originally supported full ETC1 and ETC1S, so there's some legacy stuff to be cleaned up in here.
// Add endpoint tiling support (where we force adjacent blocks to use the same endpoints during quantization), for a ~10% or more increase in bitrate at same SSIM. The backend already supports this.
//
#include "../transcoder/basisu.h"
#include "basisu_frontend.h"
#include "basisu_opencl.h"
#include <unordered_set>
#include <unordered_map>

#if BASISU_SUPPORT_SSE
#define CPPSPMD_NAME …
#include "basisu_kernels_declares.h"
#endif

#define BASISU_FRONTEND_VERIFY(c) …

namespace basisu
{
	const uint32_t cMaxCodebookCreationThreads = …;

	const uint32_t BASISU_MAX_ENDPOINT_REFINEMENT_STEPS = …;
	//const uint32_t BASISU_MAX_SELECTOR_REFINEMENT_STEPS = 3;

	const uint32_t BASISU_ENDPOINT_PARENT_CODEBOOK_SIZE = …;
	const uint32_t BASISU_SELECTOR_PARENT_CODEBOOK_SIZE_COMP_LEVEL_01 = …;
	const uint32_t BASISU_SELECTOR_PARENT_CODEBOOK_SIZE_COMP_LEVEL_DEFAULT = …;
	
	// TODO - How to handle internal verifies in the basisu lib
	static inline void handle_verify_failure(int line)
	{ … }
			
	bool basisu_frontend::init(const params &p)
	{ … }

	bool basisu_frontend::compress()
	{ … }

	bool basisu_frontend::init_global_codebooks()
	{ … }

	void basisu_frontend::introduce_special_selector_clusters()
	{ … }

	// This method will change the number and ordering of the selector codebook clusters.
	void basisu_frontend::optimize_selector_codebook()
	{ … }

	void basisu_frontend::init_etc1_images()
	{ … }

	void basisu_frontend::init_endpoint_training_vectors()
	{ … }

	void basisu_frontend::generate_endpoint_clusters()
	{ … }

	// Iterate through each array of endpoint cluster block indices and set the m_block_endpoint_clusters_indices[][] array to indicaste which cluster index each block uses.
	void basisu_frontend::generate_block_endpoint_clusters()
	{ … }

	void basisu_frontend::compute_endpoint_clusters_within_each_parent_cluster()
	{ … }

	void basisu_frontend::compute_endpoint_subblock_error_vec()
	{ … }
		
	void basisu_frontend::introduce_new_endpoint_clusters()
	{ … }

	struct color_rgba_hasher
	{ … };
		
	// Given each endpoint cluster, gather all the block pixels which are in that cluster and compute optimized ETC1S endpoints for them.
	// TODO: Don't optimize endpoint clusters which haven't changed.
	// If step>=1, we check to ensure the new endpoint values actually decrease quantization error.
	void basisu_frontend::generate_endpoint_codebook(uint32_t step)
	{ … }

	bool basisu_frontend::check_etc1s_constraints() const
	{ … }

	// For each block, determine which ETC1S endpoint cluster can encode that block with lowest error.
	// This reassigns blocks to different endpoint clusters.
	uint32_t basisu_frontend::refine_endpoint_clusterization()
	{ … }

	void basisu_frontend::eliminate_redundant_or_empty_endpoint_clusters()
	{ … }

	void basisu_frontend::create_initial_packed_texture()
	{ … }

	void basisu_frontend::compute_selector_clusters_within_each_parent_cluster()
	{ … }

	void basisu_frontend::generate_selector_clusters()
	{ … }

	void basisu_frontend::create_optimized_selector_codebook(uint32_t iter)
	{ … }

	// For each block: Determine which quantized selectors best encode that block, given its quantized endpoints.
	// Note that this method may leave some empty clusters (i.e. arrays with no block indices), including at the end.
	void basisu_frontend::find_optimal_selector_clusters_for_each_block()
	{ … }

	// TODO: Remove old ETC1 specific stuff, and thread this.
	uint32_t basisu_frontend::refine_block_endpoints_given_selectors()
	{ … }

	void basisu_frontend::dump_endpoint_clusterization_visualization(const char *pFilename, bool vis_endpoint_colors)
	{ … }

	void basisu_frontend::finalize()
	{ … }

	// The backend has remapped the block endpoints while optimizing the output symbols for better rate distortion performance, so let's go and reoptimize the endpoint codebook.
	// This is currently the only place where the backend actually goes and changes the quantization and calls the frontend to fix things up. 
	// This is basically a bottom up clusterization stage, where some leaves can be combined.
	void basisu_frontend::reoptimize_remapped_endpoints(const uint_vec &new_block_endpoints, int_vec &old_to_new_endpoint_cluster_indices, bool optimize_final_codebook, uint_vec *pBlock_selector_indices)
	{ … }

	// Endpoint clusterization hierarchy integrity checker.
	// Note this doesn't check for empty clusters.
	bool basisu_frontend::validate_endpoint_cluster_hierarchy(bool ensure_clusters_have_same_parents) const
	{ … }

	// This is very slow and only intended for debugging/development. It's enabled using the "-validate_etc1s" command line option.
	bool basisu_frontend::validate_output() const
	{ … }

	void basisu_frontend::dump_debug_image(const char *pFilename, uint32_t first_block, uint32_t num_blocks_x, uint32_t num_blocks_y, bool output_blocks)
	{ … }

} // namespace basisu
godot/thirdparty/basis_universal/encoder/basisu_frontend.cpp
