godot/thirdparty/basis_universal/basisu_frontend.h

355 lines
12 KiB
C++
Raw Normal View History

// basisu_frontend.h
// Copyright (C) 2019 Binomial LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "basisu_enc.h"
#include "basisu_etc.h"
#include "basisu_gpu_texture.h"
#include "basisu_global_selector_palette_helpers.h"
#include "transcoder/basisu_file_headers.h"
namespace basisu
{
struct vec2U
{
uint32_t m_comps[2];
vec2U() { }
vec2U(uint32_t a, uint32_t b) { set(a, b); }
void set(uint32_t a, uint32_t b) { m_comps[0] = a; m_comps[1] = b; }
uint32_t operator[] (uint32_t i) const { assert(i < 2); return m_comps[i]; }
uint32_t &operator[] (uint32_t i) { assert(i < 2); return m_comps[i]; }
};
const uint32_t BASISU_DEFAULT_COMPRESSION_LEVEL = 1;
const uint32_t BASISU_MAX_COMPRESSION_LEVEL = 5;
class basisu_frontend
{
BASISU_NO_EQUALS_OR_COPY_CONSTRUCT(basisu_frontend);
public:
basisu_frontend() :
m_total_blocks(0),
m_total_pixels(0),
m_endpoint_refinement(false),
m_use_hierarchical_endpoint_codebooks(false),
m_use_hierarchical_selector_codebooks(false),
m_num_endpoint_codebook_iterations(0),
m_num_selector_codebook_iterations(0)
{
}
enum
{
cMaxEndpointClusters = 16128,
cMaxSelectorClusters = 16128,
};
struct params
{
params() :
m_num_source_blocks(0),
m_pSource_blocks(NULL),
m_max_endpoint_clusters(256),
m_max_selector_clusters(256),
m_compression_level(BASISU_DEFAULT_COMPRESSION_LEVEL),
m_perceptual(true),
m_debug_stats(false),
m_debug_images(false),
m_dump_endpoint_clusterization(true),
m_pGlobal_sel_codebook(NULL),
m_num_global_sel_codebook_pal_bits(0),
m_num_global_sel_codebook_mod_bits(0),
m_use_hybrid_selector_codebooks(false),
m_hybrid_codebook_quality_thresh(0.0f),
m_validate(false),
m_tex_type(basist::cBASISTexType2D),
m_multithreaded(false),
m_disable_hierarchical_endpoint_codebooks(false),
m_pJob_pool(nullptr)
{
}
uint32_t m_num_source_blocks;
pixel_block *m_pSource_blocks;
uint32_t m_max_endpoint_clusters;
uint32_t m_max_selector_clusters;
uint32_t m_compression_level;
bool m_perceptual;
bool m_debug_stats;
bool m_debug_images;
bool m_dump_endpoint_clusterization;
bool m_validate;
bool m_multithreaded;
bool m_disable_hierarchical_endpoint_codebooks;
const basist::etc1_global_selector_codebook *m_pGlobal_sel_codebook;
uint32_t m_num_global_sel_codebook_pal_bits;
uint32_t m_num_global_sel_codebook_mod_bits;
bool m_use_hybrid_selector_codebooks;
float m_hybrid_codebook_quality_thresh;
basist::basis_texture_type m_tex_type;
job_pool *m_pJob_pool;
};
bool init(const params &p);
bool compress();
const params &get_params() const { return m_params; }
const pixel_block &get_source_pixel_block(uint32_t i) const { return m_source_blocks[i]; }
// RDO output blocks
uint32_t get_total_output_blocks() const { return static_cast<uint32_t>(m_encoded_blocks.size()); }
const etc_block &get_output_block(uint32_t block_index) const { return m_encoded_blocks[block_index]; }
const etc_block_vec &get_output_blocks() const { return m_encoded_blocks; }
// "Best" ETC1S blocks
const etc_block &get_etc1s_block(uint32_t block_index) const { return m_etc1_blocks_etc1s[block_index]; }
// Per-block flags
bool get_diff_flag(uint32_t block_index) const { return m_encoded_blocks[block_index].get_diff_bit(); }
// Endpoint clusters
uint32_t get_total_endpoint_clusters() const { return static_cast<uint32_t>(m_endpoint_clusters.size()); }
uint32_t get_subblock_endpoint_cluster_index(uint32_t block_index, uint32_t subblock_index) const { return m_block_endpoint_clusters_indices[block_index][subblock_index]; }
const color_rgba &get_endpoint_cluster_unscaled_color(uint32_t cluster_index, bool individual_mode) const { return m_endpoint_cluster_etc_params[cluster_index].m_color_unscaled[individual_mode]; }
uint32_t get_endpoint_cluster_inten_table(uint32_t cluster_index, bool individual_mode) const { return m_endpoint_cluster_etc_params[cluster_index].m_inten_table[individual_mode]; }
bool get_endpoint_cluster_color_is_used(uint32_t cluster_index, bool individual_mode) const { return m_endpoint_cluster_etc_params[cluster_index].m_color_used[individual_mode]; }
// Selector clusters
uint32_t get_total_selector_clusters() const { return static_cast<uint32_t>(m_selector_cluster_indices.size()); }
uint32_t get_block_selector_cluster_index(uint32_t block_index) const { return m_block_selector_cluster_index[block_index]; }
const etc_block &get_selector_cluster_selector_bits(uint32_t cluster_index) const { return m_optimized_cluster_selectors[cluster_index]; }
const basist::etc1_global_selector_codebook_entry_id_vec &get_selector_cluster_global_selector_entry_ids() const { return m_optimized_cluster_selector_global_cb_ids; }
const bool_vec &get_selector_cluster_uses_global_cb_vec() const { return m_selector_cluster_uses_global_cb; }
// Returns block indices using each selector cluster
const uint_vec &get_selector_cluster_block_indices(uint32_t selector_cluster_index) const { return m_selector_cluster_indices[selector_cluster_index]; }
void dump_debug_image(const char *pFilename, uint32_t first_block, uint32_t num_blocks_x, uint32_t num_blocks_y, bool output_blocks);
void 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 = nullptr);
private:
params m_params;
uint32_t m_total_blocks;
uint32_t m_total_pixels;
bool m_endpoint_refinement;
bool m_use_hierarchical_endpoint_codebooks;
bool m_use_hierarchical_selector_codebooks;
uint32_t m_num_endpoint_codebook_iterations;
uint32_t m_num_selector_codebook_iterations;
// Source pixels for each blocks
pixel_block_vec m_source_blocks;
// The quantized ETC1S texture.
etc_block_vec m_encoded_blocks;
// Quantized blocks after endpoint quant, but before selector quant
etc_block_vec m_orig_encoded_blocks;
// Full quality ETC1S texture
etc_block_vec m_etc1_blocks_etc1s;
typedef vec<6, float> vec6F;
// Endpoint clusterizer
typedef tree_vector_quant<vec6F> vec6F_quantizer;
vec6F_quantizer m_endpoint_clusterizer;
// For each endpoint cluster: An array of which subblock indices (block_index*2+subblock) are located in that cluster.
// Array of block indices for each endpoint cluster
std::vector<uint_vec> m_endpoint_clusters;
// Array of block indices for each parent endpoint cluster
std::vector<uint_vec> m_endpoint_parent_clusters;
// Each block's parent cluster index
uint8_vec m_block_parent_endpoint_cluster;
// Array of endpoint cluster indices for each parent endpoint cluster
std::vector<uint_vec> m_endpoint_clusters_within_each_parent_cluster;
struct endpoint_cluster_etc_params
{
endpoint_cluster_etc_params()
{
clear();
}
void clear()
{
clear_obj(m_color_unscaled);
clear_obj(m_inten_table);
clear_obj(m_color_error);
m_subblocks.clear();
clear_obj(m_color_used);
m_valid = false;
}
// TODO: basisu doesn't use individual mode.
color_rgba m_color_unscaled[2]; // [use_individual_mode]
uint32_t m_inten_table[2];
uint64_t m_color_error[2];
uint_vec m_subblocks;
bool m_color_used[2];
bool m_valid;
bool operator== (const endpoint_cluster_etc_params &other) const
{
for (uint32_t i = 0; i < 2; i++)
{
if (m_color_unscaled[i] != other.m_color_unscaled[i])
return false;
}
if (m_inten_table[0] != other.m_inten_table[0])
return false;
if (m_inten_table[1] != other.m_inten_table[1])
return false;
return true;
}
bool operator< (const endpoint_cluster_etc_params &other) const
{
for (uint32_t i = 0; i < 2; i++)
{
if (m_color_unscaled[i] < other.m_color_unscaled[i])
return true;
else if (m_color_unscaled[i] != other.m_color_unscaled[i])
return false;
}
if (m_inten_table[0] < other.m_inten_table[0])
return true;
else if (m_inten_table[0] == other.m_inten_table[0])
{
if (m_inten_table[1] < other.m_inten_table[1])
return true;
}
return false;
}
};
typedef std::vector<endpoint_cluster_etc_params> cluster_subblock_etc_params_vec;
// Each endpoint cluster's ETC1S parameters
cluster_subblock_etc_params_vec m_endpoint_cluster_etc_params;
// The endpoint cluster index used by each ETC1 subblock.
std::vector<vec2U> m_block_endpoint_clusters_indices;
// The block(s) within each selector cluster
// Note: If you add anything here that uses selector cluster indicies, be sure to update optimize_selector_codebook()!
std::vector<uint_vec> m_selector_cluster_indices;
// The selector bits for each selector cluster.
std::vector<etc_block> m_optimized_cluster_selectors;
// The block(s) within each parent selector cluster.
std::vector<uint_vec> m_selector_parent_cluster_indices;
// Each block's parent selector cluster
uint8_vec m_block_parent_selector_cluster;
// Array of selector cluster indices for each parent selector cluster
std::vector<uint_vec> m_selector_clusters_within_each_parent_cluster;
basist::etc1_global_selector_codebook_entry_id_vec m_optimized_cluster_selector_global_cb_ids;
bool_vec m_selector_cluster_uses_global_cb;
// Each block's selector cluster index
std::vector<uint32_t> m_block_selector_cluster_index;
struct subblock_endpoint_quant_err
{
uint64_t m_total_err;
uint32_t m_cluster_index;
uint32_t m_cluster_subblock_index;
uint32_t m_block_index;
uint32_t m_subblock_index;
bool operator< (const subblock_endpoint_quant_err &rhs) const
{
if (m_total_err < rhs.m_total_err)
return true;
else if (m_total_err == rhs.m_total_err)
{
if (m_block_index < rhs.m_block_index)
return true;
else if (m_block_index == rhs.m_block_index)
return m_subblock_index < rhs.m_subblock_index;
}
return false;
}
};
// The sorted subblock endpoint quant error for each endpoint cluster
std::vector<subblock_endpoint_quant_err> m_subblock_endpoint_quant_err_vec;
std::mutex m_lock;
//-----------------------------------------------------------------------------
void init_etc1_images();
void init_endpoint_training_vectors();
void dump_endpoint_clusterization_visualization(const char *pFilename, bool vis_endpoint_colors);
void generate_endpoint_clusters();
void compute_endpoint_subblock_error_vec();
void introduce_new_endpoint_clusters();
void generate_endpoint_codebook(uint32_t step);
uint32_t refine_endpoint_clusterization();
void eliminate_redundant_or_empty_endpoint_clusters();
void generate_block_endpoint_clusters();
void compute_endpoint_clusters_within_each_parent_cluster();
void compute_selector_clusters_within_each_parent_cluster();
void create_initial_packed_texture();
void generate_selector_clusters();
void create_optimized_selector_codebook(uint32_t iter);
void find_optimal_selector_clusters_for_each_block();
uint32_t refine_block_endpoints_given_selectors();
void finalize();
bool validate_output() const;
void introduce_special_selector_clusters();
void optimize_selector_codebook();
bool check_etc1s_constraints() const;
};
} // namespace basisu