basisu_backend.h - external/github.com/BinomialLLC/basis_universal - Git at Google

 // basisu_backend.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 "transcoder/basisu.h"
 #include "basisu_enc.h"
 #include "transcoder/basisu_transcoder_internal.h"
 #include "transcoder/basisu_global_selector_palette.h"
 #include "basisu_frontend.h"

 namespace basisu
 {
 	struct encoder_block
 	{
 		encoder_block()
 		{
 			clear();
 		}

 		uint32_t m_endpoint_predictor;

 		int m_endpoint_index;
 		int m_selector_index;

 		int m_selector_history_buf_index;

 		bool m_is_cr_target;
 		void clear()
 		{
 			m_endpoint_predictor = 0;

 			m_endpoint_index = 0;
 			m_selector_index = 0;

 			m_selector_history_buf_index = 0;
 			m_is_cr_target = false;
 		}
 	};

 	typedef std::vector<encoder_block> encoder_block_vec;
 	typedef vector2D<encoder_block> encoder_block_vec2D;

 	struct etc1_endpoint_palette_entry
 	{
 		etc1_endpoint_palette_entry()
 		{
 			clear();
 		}

 		color_rgba m_color5;
 		uint32_t m_inten5;
 		bool m_color5_valid;

 		void clear()
 		{
 			clear_obj(*this);
 		}
 	};

 	typedef std::vector<etc1_endpoint_palette_entry> etc1_endpoint_palette_entry_vec;

 	struct basisu_backend_params
 	{
 		bool m_etc1s;
 		bool m_debug, m_debug_images;
 		float m_endpoint_rdo_quality_thresh;
 		float m_selector_rdo_quality_thresh;
 		uint32_t m_compression_level;

 		bool m_use_global_sel_codebook;
 		uint32_t m_global_sel_codebook_pal_bits;
 		uint32_t m_global_sel_codebook_mod_bits;
 		bool m_use_hybrid_sel_codebooks;

 		basisu_backend_params()
 		{
 			clear();
 		}

 		void clear()
 		{
 			m_etc1s = false;
 			m_debug = false;
 			m_debug_images = false;
 			m_endpoint_rdo_quality_thresh = 0.0f;
 			m_selector_rdo_quality_thresh = 0.0f;
 			m_compression_level = 0;

 			m_use_global_sel_codebook = false;
 			m_global_sel_codebook_pal_bits = ETC1_GLOBAL_SELECTOR_CODEBOOK_MAX_PAL_BITS;
 			m_global_sel_codebook_mod_bits = basist::etc1_global_palette_entry_modifier::cTotalBits;
 			m_use_hybrid_sel_codebooks = false;
 		}
 	};

 	struct basisu_backend_slice_desc
 	{
 		basisu_backend_slice_desc()
 		{
 			clear();
 		}
 		void clear()
 		{
 			clear_obj(*this);
 		}
 		uint32_t m_first_block_index;

 		uint32_t m_orig_width;
 		uint32_t m_orig_height;

 		uint32_t m_width;
 		uint32_t m_height;

 		uint32_t m_num_blocks_x;
 		uint32_t m_num_blocks_y;

 		uint32_t m_num_macroblocks_x;
 		uint32_t m_num_macroblocks_y;

 		uint32_t m_source_file_index;		// also the basis image index
 		uint32_t m_mip_index;
 		bool m_alpha;
 		bool m_iframe;
 	};

 	typedef std::vector<basisu_backend_slice_desc> basisu_backend_slice_desc_vec;

 	struct basisu_backend_output
 	{
 		bool m_etc1s;

 		uint32_t m_num_endpoints;
 		uint32_t m_num_selectors;

 		uint8_vec m_endpoint_palette;
 		uint8_vec m_selector_palette;

 		basisu_backend_slice_desc_vec m_slice_desc;

 		uint8_vec m_slice_image_tables;
 		std::vector<uint8_vec> m_slice_image_data;
 		uint16_vec m_slice_image_crcs;

 		basisu_backend_output()
 		{
 			clear();
 		}

 		void clear()
 		{
 			m_etc1s = false;

 			m_num_endpoints = 0;
 			m_num_selectors = 0;

 			m_endpoint_palette.clear();
 			m_selector_palette.clear();
 			m_slice_desc.clear();
 			m_slice_image_tables.clear();
 			m_slice_image_data.clear();
 			m_slice_image_crcs.clear();
 		}

 		uint32_t get_output_size_estimate() const
 		{
 			uint32_t total_compressed_bytes = (uint32_t)(m_slice_image_tables.size() + m_endpoint_palette.size() + m_selector_palette.size());
 			for (uint32_t i = 0; i < m_slice_image_data.size(); i++)
 				total_compressed_bytes += (uint32_t)m_slice_image_data[i].size();

 			return total_compressed_bytes;
 		}
 	};

 	class basisu_backend
 	{
 		BASISU_NO_EQUALS_OR_COPY_CONSTRUCT(basisu_backend);

 	public:

 		basisu_backend();

 		void clear();

 		void init(basisu_frontend *pFront_end, basisu_backend_params &params, const basisu_backend_slice_desc_vec &slice_desc, const basist::etc1_global_selector_codebook *pGlobal_sel_codebook);

 		uint32_t encode();

 		const basisu_backend_output &get_output() const { return m_output; }

 	private:
 		basisu_frontend *m_pFront_end;
 		basisu_backend_params m_params;
 		basisu_backend_slice_desc_vec m_slices;
 		basisu_backend_output m_output;
 		const basist::etc1_global_selector_codebook *m_pGlobal_sel_codebook;

 		etc1_endpoint_palette_entry_vec m_endpoint_palette;
 		basist::etc1_selector_palette_entry_vec m_selector_palette;

 		struct etc1_global_selector_cb_entry_desc
 		{
 			uint32_t m_pal_index;
 			uint32_t m_mod_index;
 			bool m_was_used;
 		};

 		typedef std::vector<etc1_global_selector_cb_entry_desc> etc1_global_selector_cb_entry_desc_vec;

 		etc1_global_selector_cb_entry_desc_vec m_global_selector_palette_desc;

 		std::vector<encoder_block_vec2D> m_slice_encoder_blocks;

 		// Maps OLD to NEW endpoint/selector indices
 		uint_vec m_endpoint_remap_table_old_to_new;
 		uint_vec m_endpoint_remap_table_new_to_old;

 		uint_vec m_selector_remap_table_old_to_new;

 		// Maps NEW to OLD endpoint/selector indices
 		uint_vec m_selector_remap_table_new_to_old;

 		uint32_t get_total_slices() const
 		{
 			return (uint32_t)m_slices.size();
 		}

 		uint32_t get_total_slice_blocks() const
 		{
 			return m_pFront_end->get_total_output_blocks();
 		}

 		uint32_t get_block_index(uint32_t slice_index, uint32_t block_x, uint32_t block_y) const
 		{
 			const basisu_backend_slice_desc &slice = m_slices[slice_index];

 			assert((block_x < slice.m_num_blocks_x) && (block_y < slice.m_num_blocks_y));

 			return slice.m_first_block_index + block_y * slice.m_num_blocks_x + block_x;
 		}

 		uint32_t get_total_blocks(uint32_t slice_index) const
 		{
 			return m_slices[slice_index].m_num_blocks_x * m_slices[slice_index].m_num_blocks_y;
 		}

 		uint32_t get_total_blocks() const
 		{
 			uint32_t total_blocks = 0;
 			for (uint32_t i = 0; i < m_slices.size(); i++)
 				total_blocks += get_total_blocks(i);
 			return total_blocks;
 		}

 		// Returns the total number of input texels, not counting padding up to blocks/macroblocks.
 		uint32_t get_total_input_texels(uint32_t slice_index) const
 		{
 			return m_slices[slice_index].m_orig_width * m_slices[slice_index].m_orig_height;
 		}

 		uint32_t get_total_input_texels() const
 		{
 			uint32_t total_texels = 0;
 			for (uint32_t i = 0; i < m_slices.size(); i++)
 				total_texels += get_total_input_texels(i);
 			return total_texels;
 		}

 		int find_slice(uint32_t block_index, uint32_t *pBlock_x, uint32_t *pBlock_y) const
 		{
 			for (uint32_t i = 0; i < m_slices.size(); i++)
 			{
 				if ((block_index >= m_slices[i].m_first_block_index) && (block_index < (m_slices[i].m_first_block_index + m_slices[i].m_num_blocks_x * m_slices[i].m_num_blocks_y)))
 				{
 					const uint32_t ofs = block_index - m_slices[i].m_first_block_index;
 					const uint32_t x = ofs % m_slices[i].m_num_blocks_x;
 					const uint32_t y = ofs / m_slices[i].m_num_blocks_x;

 					if (pBlock_x) *pBlock_x = x;
 					if (pBlock_y) *pBlock_y = y;

 					return i;
 				}
 			}
 			return -1;
 		}

 		void create_endpoint_palette();

 		void create_selector_palette();

 		// endpoint palette
 		//   5:5:5 and predicted 4:4:4 colors, 1 or 2 3-bit intensity table indices
 		// selector palette
 		//   4x4 2-bit selectors

 		// per-macroblock:
 		//  4 diff bits
 		//  4 flip bits
 		//  Endpoint template index, 1-8 endpoint indices
 		//      Alternately, if no template applies, we can send 4 ETC1S bits followed by 4-8 endpoint indices
 		//  4 selector indices

 		void reoptimize_and_sort_endpoints_codebook(uint32_t total_block_endpoints_remapped, uint_vec &all_endpoint_indices);
 		void sort_selector_codebook();
 		void create_encoder_blocks();
 		void compute_slice_crcs();
 		bool encode_image();
 		bool encode_endpoint_palette();
 		bool encode_selector_palette();
 		int find_video_frame(int slice_index, int delta);
 		void check_for_valid_cr_blocks();
 	};

 } // namespace basisu
	// basisu_backend.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 "transcoder/basisu.h"
	#include "basisu_enc.h"
	#include "transcoder/basisu_transcoder_internal.h"
	#include "transcoder/basisu_global_selector_palette.h"
	#include "basisu_frontend.h"

	namespace basisu
	{
	struct encoder_block
	{
	encoder_block()
	{
	clear();
	}

	uint32_t m_endpoint_predictor;

	int m_endpoint_index;
	int m_selector_index;

	int m_selector_history_buf_index;

	bool m_is_cr_target;
	void clear()
	{
	m_endpoint_predictor = 0;

	m_endpoint_index = 0;
	m_selector_index = 0;

	m_selector_history_buf_index = 0;
	m_is_cr_target = false;
	}
	};

	typedef std::vector<encoder_block> encoder_block_vec;
	typedef vector2D<encoder_block> encoder_block_vec2D;

	struct etc1_endpoint_palette_entry
	{
	etc1_endpoint_palette_entry()
	{
	clear();
	}

	color_rgba m_color5;
	uint32_t m_inten5;
	bool m_color5_valid;

	void clear()
	{
	clear_obj(*this);
	}
	};

	typedef std::vector<etc1_endpoint_palette_entry> etc1_endpoint_palette_entry_vec;

	struct basisu_backend_params
	{
	bool m_etc1s;
	bool m_debug, m_debug_images;
	float m_endpoint_rdo_quality_thresh;
	float m_selector_rdo_quality_thresh;
	uint32_t m_compression_level;

	bool m_use_global_sel_codebook;
	uint32_t m_global_sel_codebook_pal_bits;
	uint32_t m_global_sel_codebook_mod_bits;
	bool m_use_hybrid_sel_codebooks;

	basisu_backend_params()
	{
	clear();
	}

	void clear()
	{
	m_etc1s = false;
	m_debug = false;
	m_debug_images = false;
	m_endpoint_rdo_quality_thresh = 0.0f;
	m_selector_rdo_quality_thresh = 0.0f;
	m_compression_level = 0;

	m_use_global_sel_codebook = false;
	m_global_sel_codebook_pal_bits = ETC1_GLOBAL_SELECTOR_CODEBOOK_MAX_PAL_BITS;
	m_global_sel_codebook_mod_bits = basist::etc1_global_palette_entry_modifier::cTotalBits;
	m_use_hybrid_sel_codebooks = false;
	}
	};

	struct basisu_backend_slice_desc
	{
	basisu_backend_slice_desc()
	{
	clear();
	}
	void clear()
	{
	clear_obj(*this);
	}
	uint32_t m_first_block_index;

	uint32_t m_orig_width;
	uint32_t m_orig_height;

	uint32_t m_width;
	uint32_t m_height;

	uint32_t m_num_blocks_x;
	uint32_t m_num_blocks_y;

	uint32_t m_num_macroblocks_x;
	uint32_t m_num_macroblocks_y;

	uint32_t m_source_file_index; // also the basis image index
	uint32_t m_mip_index;
	bool m_alpha;
	bool m_iframe;
	};

	typedef std::vector<basisu_backend_slice_desc> basisu_backend_slice_desc_vec;

	struct basisu_backend_output
	{
	bool m_etc1s;

	uint32_t m_num_endpoints;
	uint32_t m_num_selectors;

	uint8_vec m_endpoint_palette;
	uint8_vec m_selector_palette;

	basisu_backend_slice_desc_vec m_slice_desc;

	uint8_vec m_slice_image_tables;
	std::vector<uint8_vec> m_slice_image_data;
	uint16_vec m_slice_image_crcs;

	basisu_backend_output()
	{
	clear();
	}

	void clear()
	{
	m_etc1s = false;

	m_num_endpoints = 0;
	m_num_selectors = 0;

	m_endpoint_palette.clear();
	m_selector_palette.clear();
	m_slice_desc.clear();
	m_slice_image_tables.clear();
	m_slice_image_data.clear();
	m_slice_image_crcs.clear();
	}

	uint32_t get_output_size_estimate() const
	{
	uint32_t total_compressed_bytes = (uint32_t)(m_slice_image_tables.size() + m_endpoint_palette.size() + m_selector_palette.size());
	for (uint32_t i = 0; i < m_slice_image_data.size(); i++)
	total_compressed_bytes += (uint32_t)m_slice_image_data[i].size();

	return total_compressed_bytes;
	}
	};

	class basisu_backend
	{
	BASISU_NO_EQUALS_OR_COPY_CONSTRUCT(basisu_backend);

	public:

	basisu_backend();

	void clear();

	void init(basisu_frontend pFront_end, basisu_backend_params &params, const basisu_backend_slice_desc_vec &slice_desc, const basist::etc1_global_selector_codebook pGlobal_sel_codebook);

	uint32_t encode();

	const basisu_backend_output &get_output() const { return m_output; }

	private:
	basisu_frontend *m_pFront_end;
	basisu_backend_params m_params;
	basisu_backend_slice_desc_vec m_slices;
	basisu_backend_output m_output;
	const basist::etc1_global_selector_codebook *m_pGlobal_sel_codebook;

	etc1_endpoint_palette_entry_vec m_endpoint_palette;
	basist::etc1_selector_palette_entry_vec m_selector_palette;

	struct etc1_global_selector_cb_entry_desc
	{
	uint32_t m_pal_index;
	uint32_t m_mod_index;
	bool m_was_used;
	};

	typedef std::vector<etc1_global_selector_cb_entry_desc> etc1_global_selector_cb_entry_desc_vec;

	etc1_global_selector_cb_entry_desc_vec m_global_selector_palette_desc;

	std::vector<encoder_block_vec2D> m_slice_encoder_blocks;

	// Maps OLD to NEW endpoint/selector indices
	uint_vec m_endpoint_remap_table_old_to_new;
	uint_vec m_endpoint_remap_table_new_to_old;

	uint_vec m_selector_remap_table_old_to_new;

	// Maps NEW to OLD endpoint/selector indices
	uint_vec m_selector_remap_table_new_to_old;

	uint32_t get_total_slices() const
	{
	return (uint32_t)m_slices.size();
	}

	uint32_t get_total_slice_blocks() const
	{
	return m_pFront_end->get_total_output_blocks();
	}

	uint32_t get_block_index(uint32_t slice_index, uint32_t block_x, uint32_t block_y) const
	{
	const basisu_backend_slice_desc &slice = m_slices[slice_index];

	assert((block_x < slice.m_num_blocks_x) && (block_y < slice.m_num_blocks_y));

	return slice.m_first_block_index + block_y * slice.m_num_blocks_x + block_x;
	}

	uint32_t get_total_blocks(uint32_t slice_index) const
	{
	return m_slices[slice_index].m_num_blocks_x * m_slices[slice_index].m_num_blocks_y;
	}

	uint32_t get_total_blocks() const
	{
	uint32_t total_blocks = 0;
	for (uint32_t i = 0; i < m_slices.size(); i++)
	total_blocks += get_total_blocks(i);
	return total_blocks;
	}

	// Returns the total number of input texels, not counting padding up to blocks/macroblocks.
	uint32_t get_total_input_texels(uint32_t slice_index) const
	{
	return m_slices[slice_index].m_orig_width * m_slices[slice_index].m_orig_height;
	}

	uint32_t get_total_input_texels() const
	{
	uint32_t total_texels = 0;
	for (uint32_t i = 0; i < m_slices.size(); i++)
	total_texels += get_total_input_texels(i);
	return total_texels;
	}

	int find_slice(uint32_t block_index, uint32_t pBlock_x, uint32_t pBlock_y) const
	{
	for (uint32_t i = 0; i < m_slices.size(); i++)
	{
	if ((block_index >= m_slices[i].m_first_block_index) && (block_index < (m_slices[i].m_first_block_index + m_slices[i].m_num_blocks_x * m_slices[i].m_num_blocks_y)))
	{
	const uint32_t ofs = block_index - m_slices[i].m_first_block_index;
	const uint32_t x = ofs % m_slices[i].m_num_blocks_x;
	const uint32_t y = ofs / m_slices[i].m_num_blocks_x;

	if (pBlock_x) *pBlock_x = x;
	if (pBlock_y) *pBlock_y = y;

	return i;
	}
	}
	return -1;
	}

	void create_endpoint_palette();

	void create_selector_palette();

	// endpoint palette
	// 5:5:5 and predicted 4:4:4 colors, 1 or 2 3-bit intensity table indices
	// selector palette
	// 4x4 2-bit selectors

	// per-macroblock:
	// 4 diff bits
	// 4 flip bits
	// Endpoint template index, 1-8 endpoint indices
	// Alternately, if no template applies, we can send 4 ETC1S bits followed by 4-8 endpoint indices
	// 4 selector indices

	void reoptimize_and_sort_endpoints_codebook(uint32_t total_block_endpoints_remapped, uint_vec &all_endpoint_indices);
	void sort_selector_codebook();
	void create_encoder_blocks();
	void compute_slice_crcs();
	bool encode_image();
	bool encode_endpoint_palette();
	bool encode_selector_palette();
	int find_video_frame(int slice_index, int delta);
	void check_for_valid_cr_blocks();
	};

	} // namespace basisu