ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xenia-canary/third_party/crunch/crnlib/crn_comp.cpp

2179 lines
72 KiB
C++
Raw Normal View History

Adding Crunch at r319.
2014-01-21 07:02:34 +00:00
// File: crn_comp.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_console.h"
#include "crn_comp.h"
#include "crn_zeng.h"
#include "crn_checksum.h"
#define CRNLIB_CREATE_DEBUG_IMAGES 0
#define CRNLIB_ENABLE_DEBUG_MESSAGES 0
namespace crnlib
{
static const uint cEncodingMapNumChunksPerCode = 3;
crn_comp::crn_comp() :
m_pParams(NULL)
{
}
crn_comp::~crn_comp()
{
}
float crn_comp::color_endpoint_similarity_func(uint index_a, uint index_b, void* pContext)
{
dxt_hc& hvq = *static_cast<dxt_hc*>(pContext);
uint endpoint_a = hvq.get_color_endpoint(index_a);
uint endpoint_b = hvq.get_color_endpoint(index_b);
color_quad_u8 a[2];
a[0] = dxt1_block::unpack_color((uint16)(endpoint_a & 0xFFFF), true);
a[1] = dxt1_block::unpack_color((uint16)((endpoint_a >> 16) & 0xFFFF), true);
color_quad_u8 b[2];
b[0] = dxt1_block::unpack_color((uint16)(endpoint_b & 0xFFFF), true);
b[1] = dxt1_block::unpack_color((uint16)((endpoint_b >> 16) & 0xFFFF), true);
uint total_error = color::elucidian_distance(a[0], b[0], false) + color::elucidian_distance(a[1], b[1], false);
float weight = 1.0f - math::clamp(total_error * 1.0f/8000.0f, 0.0f, 1.0f);
return weight;
}
float crn_comp::alpha_endpoint_similarity_func(uint index_a, uint index_b, void* pContext)
{
dxt_hc& hvq = *static_cast<dxt_hc*>(pContext);
uint endpoint_a = hvq.get_alpha_endpoint(index_a);
int endpoint_a_lo = dxt5_block::unpack_endpoint(endpoint_a, 0);
int endpoint_a_hi = dxt5_block::unpack_endpoint(endpoint_a, 1);
uint endpoint_b = hvq.get_alpha_endpoint(index_b);
int endpoint_b_lo = dxt5_block::unpack_endpoint(endpoint_b, 0);
int endpoint_b_hi = dxt5_block::unpack_endpoint(endpoint_b, 1);
int total_error = math::square(endpoint_a_lo - endpoint_b_lo) + math::square(endpoint_a_hi - endpoint_b_hi);
float weight = 1.0f - math::clamp(total_error * 1.0f/256.0f, 0.0f, 1.0f);
return weight;
}
void crn_comp::sort_color_endpoint_codebook(crnlib::vector<uint>& remapping, const crnlib::vector<uint>& endpoints)
{
remapping.resize(endpoints.size());
uint lowest_energy = UINT_MAX;
uint lowest_energy_index = 0;
for (uint i = 0; i < endpoints.size(); i++)
{
color_quad_u8 a(dxt1_block::unpack_color(static_cast<uint16>(endpoints[i] & 0xFFFF), true));
color_quad_u8 b(dxt1_block::unpack_color(static_cast<uint16>((endpoints[i] >> 16) & 0xFFFF), true));
uint total = a.r + a.g + a.b + b.r + b.g + b.b;
if (total < lowest_energy)
{
lowest_energy = total;
lowest_energy_index = i;
}
}
uint cur_index = lowest_energy_index;
crnlib::vector<bool> chosen_flags(endpoints.size());
uint n = 0;
for ( ; ; )
{
chosen_flags[cur_index] = true;
remapping[cur_index] = n;
n++;
if (n == endpoints.size())
break;
uint lowest_error = UINT_MAX;
uint lowest_error_index = 0;
color_quad_u8 a(dxt1_block::unpack_endpoint(endpoints[cur_index], 0, true));
color_quad_u8 b(dxt1_block::unpack_endpoint(endpoints[cur_index], 1, true));
for (uint i = 0; i < endpoints.size(); i++)
{
if (chosen_flags[i])
continue;
color_quad_u8 c(dxt1_block::unpack_endpoint(endpoints[i], 0, true));
color_quad_u8 d(dxt1_block::unpack_endpoint(endpoints[i], 1, true));
uint total = color::elucidian_distance(a, c, false) + color::elucidian_distance(b, d, false);
if (total < lowest_error)
{
lowest_error = total;
lowest_error_index = i;
}
}
cur_index = lowest_error_index;
}
}
void crn_comp::sort_alpha_endpoint_codebook(crnlib::vector<uint>& remapping, const crnlib::vector<uint>& endpoints)
{
remapping.resize(endpoints.size());
uint lowest_energy = UINT_MAX;
uint lowest_energy_index = 0;
for (uint i = 0; i < endpoints.size(); i++)
{
uint a = dxt5_block::unpack_endpoint(endpoints[i], 0);
uint b = dxt5_block::unpack_endpoint(endpoints[i], 1);
uint total = a + b;
if (total < lowest_energy)
{
lowest_energy = total;
lowest_energy_index = i;
}
}
uint cur_index = lowest_energy_index;
crnlib::vector<bool> chosen_flags(endpoints.size());
uint n = 0;
for ( ; ; )
{
chosen_flags[cur_index] = true;
remapping[cur_index] = n;
n++;
if (n == endpoints.size())
break;
uint lowest_error = UINT_MAX;
uint lowest_error_index = 0;
const int a = dxt5_block::unpack_endpoint(endpoints[cur_index], 0);
const int b = dxt5_block::unpack_endpoint(endpoints[cur_index], 1);
for (uint i = 0; i < endpoints.size(); i++)
{
if (chosen_flags[i])
continue;
const int c = dxt5_block::unpack_endpoint(endpoints[i], 0);
const int d = dxt5_block::unpack_endpoint(endpoints[i], 1);
uint total = math::square(a - c) + math::square(b - d);
if (total < lowest_error)
{
lowest_error = total;
lowest_error_index = i;
}
}
cur_index = lowest_error_index;
}
}
// The indices are only used for statistical purposes.
bool crn_comp::pack_color_endpoints(
crnlib::vector<uint8>& data,
const crnlib::vector<uint>& remapping,
const crnlib::vector<uint>& endpoint_indices,
uint trial_index)
{
trial_index;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("pack_color_endpoints: %u", trial_index);
#endif
crnlib::vector<uint> remapped_endpoints(m_hvq.get_color_endpoint_codebook_size());
for (uint i = 0; i < m_hvq.get_color_endpoint_codebook_size(); i++)
remapped_endpoints[remapping[i]] = m_hvq.get_color_endpoint(i);
const uint component_limits[6] = { 31, 63, 31, 31, 63, 31 };
symbol_histogram hist[2];
hist[0].resize(32);
hist[1].resize(64);
#if CRNLIB_CREATE_DEBUG_IMAGES
image_u8 endpoint_image(2, m_hvq.get_color_endpoint_codebook_size());
image_u8 endpoint_residual_image(2, m_hvq.get_color_endpoint_codebook_size());
#endif
crnlib::vector<uint> residual_syms;
residual_syms.reserve(m_hvq.get_color_endpoint_codebook_size()*2*3);
color_quad_u8 prev[2];
prev[0].clear();
prev[1].clear();
int total_residuals = 0;
for (uint endpoint_index = 0; endpoint_index < m_hvq.get_color_endpoint_codebook_size(); endpoint_index++)
{
const uint endpoint = remapped_endpoints[endpoint_index];
color_quad_u8 cur[2];
cur[0] = dxt1_block::unpack_color((uint16)(endpoint & 0xFFFF), false);
cur[1] = dxt1_block::unpack_color((uint16)((endpoint >> 16) & 0xFFFF), false);
#if CRNLIB_CREATE_DEBUG_IMAGES
endpoint_image(0, endpoint_index) = dxt1_block::unpack_color((uint16)(endpoint & 0xFFFF), true);
endpoint_image(1, endpoint_index) = dxt1_block::unpack_color((uint16)((endpoint >> 16) & 0xFFFF), true);
#endif
for (uint j = 0; j < 2; j++)
{
for (uint k = 0; k < 3; k++)
{
int delta = cur[j][k] - prev[j][k];
total_residuals += delta*delta;
int sym = delta & component_limits[j*3+k];
int table = (k == 1) ? 1 : 0;
hist[table].inc_freq(sym);
residual_syms.push_back(sym);
#if CRNLIB_CREATE_DEBUG_IMAGES
endpoint_residual_image(j, endpoint_index)[k] = static_cast<uint8>(sym);
#endif
}
}
prev[0] = cur[0];
prev[1] = cur[1];
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total endpoint residuals: %i", total_residuals);
#endif
if (endpoint_indices.size() > 1)
{
uint prev_index = remapping[endpoint_indices[0]];
int64 total_delta = 0;
for (uint i = 1; i < endpoint_indices.size(); i++)
{
uint cur_index = remapping[endpoint_indices[i]];
int delta = cur_index - prev_index;
prev_index = cur_index;
total_delta += delta * delta;
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total endpoint index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::write_to_file(dynamic_string(cVarArg, "color_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::write_to_file(dynamic_string(cVarArg, "color_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
#endif
static_huffman_data_model residual_dm[2];
symbol_codec codec;
codec.start_encoding(1024*1024);
// Transmit residuals
for (uint i = 0; i < 2; i++)
{
if (!residual_dm[i].init(true, hist[i], 15))
return false;
if (!codec.encode_transmit_static_huffman_data_model(residual_dm[i], false))
return false;
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for color endpoint residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
start_bits;
for (uint i = 0; i < residual_syms.size(); i++)
{
const uint sym = residual_syms[i];
const uint table = ((i % 3) == 1) ? 1 : 0;
codec.encode(sym, residual_dm[table]);
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for color endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
data.swap(codec.get_encoding_buf());
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug("Wrote a total of %u bits for color endpoint codebook", codec.encode_get_total_bits_written());
console::debug("Wrote %f bits per each color endpoint", data.size() * 8.0f / m_hvq.get_color_endpoint_codebook_size());
}
#endif
return true;
}
// The indices are only used for statistical purposes.
bool crn_comp::pack_alpha_endpoints(
crnlib::vector<uint8>& data,
const crnlib::vector<uint>& remapping,
const crnlib::vector<uint>& endpoint_indices,
uint trial_index)
{
trial_index;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("pack_alpha_endpoints: %u", trial_index);
#endif
crnlib::vector<uint> remapped_endpoints(m_hvq.get_alpha_endpoint_codebook_size());
for (uint i = 0; i < m_hvq.get_alpha_endpoint_codebook_size(); i++)
remapped_endpoints[remapping[i]] = m_hvq.get_alpha_endpoint(i);
symbol_histogram hist;
hist.resize(256);
#if CRNLIB_CREATE_DEBUG_IMAGES
image_u8 endpoint_image(2, m_hvq.get_alpha_endpoint_codebook_size());
image_u8 endpoint_residual_image(2, m_hvq.get_alpha_endpoint_codebook_size());
#endif
crnlib::vector<uint> residual_syms;
residual_syms.reserve(m_hvq.get_alpha_endpoint_codebook_size()*2*3);
uint prev[2];
utils::zero_object(prev);
int total_residuals = 0;
for (uint endpoint_index = 0; endpoint_index < m_hvq.get_alpha_endpoint_codebook_size(); endpoint_index++)
{
const uint endpoint = remapped_endpoints[endpoint_index];
uint cur[2];
cur[0] = dxt5_block::unpack_endpoint(endpoint, 0);
cur[1] = dxt5_block::unpack_endpoint(endpoint, 1);
#if CRNLIB_CREATE_DEBUG_IMAGES
endpoint_image(0, endpoint_index) = cur[0];
endpoint_image(1, endpoint_index) = cur[1];
#endif
for (uint j = 0; j < 2; j++)
{
int delta = cur[j] - prev[j];
total_residuals += delta*delta;
int sym = delta & 255;
hist.inc_freq(sym);
residual_syms.push_back(sym);
#if CRNLIB_CREATE_DEBUG_IMAGES
endpoint_residual_image(j, endpoint_index) = static_cast<uint8>(sym);
#endif
}
prev[0] = cur[0];
prev[1] = cur[1];
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total endpoint residuals: %i", total_residuals);
#endif
if (endpoint_indices.size() > 1)
{
uint prev_index = remapping[endpoint_indices[0]];
int64 total_delta = 0;
for (uint i = 1; i < endpoint_indices.size(); i++)
{
uint cur_index = remapping[endpoint_indices[i]];
int delta = cur_index - prev_index;
prev_index = cur_index;
total_delta += delta * delta;
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total endpoint index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::write_to_file(dynamic_string(cVarArg, "alpha_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::write_to_file(dynamic_string(cVarArg, "alpha_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
#endif
static_huffman_data_model residual_dm;
symbol_codec codec;
codec.start_encoding(1024*1024);
// Transmit residuals
if (!residual_dm.init(true, hist, 15))
return false;
if (!codec.encode_transmit_static_huffman_data_model(residual_dm, false))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for alpha endpoint residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
start_bits;
for (uint i = 0; i < residual_syms.size(); i++)
{
const uint sym = residual_syms[i];
codec.encode(sym, residual_dm);
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for alpha endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
data.swap(codec.get_encoding_buf());
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug("Wrote a total of %u bits for alpha endpoint codebook", codec.encode_get_total_bits_written());
console::debug("Wrote %f bits per each alpha endpoint", data.size() * 8.0f / m_hvq.get_alpha_endpoint_codebook_size());
}
#endif
return true;
}
float crn_comp::color_selector_similarity_func(uint index_a, uint index_b, void* pContext)
{
const crnlib::vector<dxt_hc::selectors>& selectors = *static_cast< const crnlib::vector<dxt_hc::selectors>* >(pContext);
const dxt_hc::selectors& selectors_a = selectors[index_a];
const dxt_hc::selectors& selectors_b = selectors[index_b];
int total = 0;
for (uint i = 0; i < 16; i++)
{
int a = g_dxt1_to_linear[selectors_a.get_by_index(i)];
int b = g_dxt1_to_linear[selectors_b.get_by_index(i)];
int delta = a - b;
total += delta*delta;
}
float weight = 1.0f - math::clamp(total * 1.0f/20.0f, 0.0f, 1.0f);
return weight;
}
float crn_comp::alpha_selector_similarity_func(uint index_a, uint index_b, void* pContext)
{
const crnlib::vector<dxt_hc::selectors>& selectors = *static_cast< const crnlib::vector<dxt_hc::selectors>* >(pContext);
const dxt_hc::selectors& selectors_a = selectors[index_a];
const dxt_hc::selectors& selectors_b = selectors[index_b];
int total = 0;
for (uint i = 0; i < 16; i++)
{
int a = g_dxt5_to_linear[selectors_a.get_by_index(i)];
int b = g_dxt5_to_linear[selectors_b.get_by_index(i)];
int delta = a - b;
total += delta*delta;
}
float weight = 1.0f - math::clamp(total * 1.0f/100.0f, 0.0f, 1.0f);
return weight;
}
void crn_comp::sort_selector_codebook(crnlib::vector<uint>& remapping, const crnlib::vector<dxt_hc::selectors>& selectors, const uint8* pTo_linear)
{
remapping.resize(selectors.size());
uint lowest_energy = UINT_MAX;
uint lowest_energy_index = 0;
for (uint i = 0; i < selectors.size(); i++)
{
uint total = 0;
for (uint j = 0; j < 16; j++)
{
int a = pTo_linear[selectors[i].get_by_index(j)];
total += a*a;
}
if (total < lowest_energy)
{
lowest_energy = total;
lowest_energy_index = i;
}
}
uint cur_index = lowest_energy_index;
crnlib::vector<bool> chosen_flags(selectors.size());
uint n = 0;
for ( ; ; )
{
chosen_flags[cur_index] = true;
remapping[cur_index] = n;
n++;
if (n == selectors.size())
break;
uint lowest_error = UINT_MAX;
uint lowest_error_index = 0;
for (uint i = 0; i < selectors.size(); i++)
{
if (chosen_flags[i])
continue;
uint total = 0;
for (uint j = 0; j < 16; j++)
{
int a = pTo_linear[selectors[cur_index].get_by_index(j)];
int b = pTo_linear[selectors[i].get_by_index(j)];
int delta = a - b;
total += delta*delta;
}
if (total < lowest_error)
{
lowest_error = total;
lowest_error_index = i;
}
}
cur_index = lowest_error_index;
}
}
// The indices are only used for statistical purposes.
bool crn_comp::pack_selectors(
crnlib::vector<uint8>& packed_data,
const crnlib::vector<uint>& selector_indices,
const crnlib::vector<dxt_hc::selectors>& selectors,
const crnlib::vector<uint>& remapping,
uint max_selector_value,
const uint8* pTo_linear,
uint trial_index)
{
trial_index;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("pack_selectors: %u", trial_index);
#endif
crnlib::vector<dxt_hc::selectors> remapped_selectors(selectors.size());
for (uint i = 0; i < selectors.size(); i++)
remapped_selectors[remapping[i]] = selectors[i];
#if CRNLIB_CREATE_DEBUG_IMAGES
image_u8 residual_image(16, selectors.size());;
image_u8 selector_image(16, selectors.size());;
#endif
crnlib::vector<uint> residual_syms;
residual_syms.reserve(selectors.size() * 8);
const uint num_baised_selector_values = (max_selector_value * 2 + 1);
symbol_histogram hist(num_baised_selector_values * num_baised_selector_values);
dxt_hc::selectors prev_selectors;
utils::zero_object(prev_selectors);
int total_residuals = 0;
for (uint selector_index = 0; selector_index < selectors.size(); selector_index++)
{
const dxt_hc::selectors& s = remapped_selectors[selector_index];
uint prev_sym = 0;
for (uint i = 0; i < 16; i++)
{
int p = pTo_linear[crnlib_assert_range_incl<uint>(prev_selectors.get_by_index(i), max_selector_value)];
int r = pTo_linear[crnlib_assert_range_incl<uint>(s.get_by_index(i), max_selector_value)] - p;
total_residuals += r*r;
uint sym = r + max_selector_value;
CRNLIB_ASSERT(sym < num_baised_selector_values);
if (i & 1)
{
uint paired_sym = (sym * num_baised_selector_values) + prev_sym;
residual_syms.push_back(paired_sym);
hist.inc_freq(paired_sym);
}
else
prev_sym = sym;
#if CRNLIB_CREATE_DEBUG_IMAGES
selector_image(i, selector_index) = (pTo_linear[crnlib_assert_range_incl<uint>(s.get_by_index(i), max_selector_value)] * 255) / max_selector_value;
residual_image(i, selector_index) = sym;
#endif
}
prev_selectors = s;
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total selector endpoint residuals: %u", total_residuals);
#endif
if (selector_indices.size() > 1)
{
uint prev_index = remapping[selector_indices[1]];
int64 total_delta = 0;
for (uint i = 1; i < selector_indices.size(); i++)
{
uint cur_index = remapping[selector_indices[i]];
int delta = cur_index - prev_index;
prev_index = cur_index;
total_delta += delta * delta;
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total selector index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::write_to_file(dynamic_string(cVarArg, "selectors_%u_%u.tga", trial_index, max_selector_value).get_ptr(), selector_image);
image_utils::write_to_file(dynamic_string(cVarArg, "selector_residuals_%u_%u.tga", trial_index, max_selector_value).get_ptr(), residual_image);
#endif
static_huffman_data_model residual_dm;
symbol_codec codec;
codec.start_encoding(1024*1024);
// Transmit residuals
if (!residual_dm.init(true, hist, 15))
return false;
if (!codec.encode_transmit_static_huffman_data_model(residual_dm, false))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for selector residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
start_bits;
for (uint i = 0; i < residual_syms.size(); i++)
{
const uint sym = residual_syms[i];
codec.encode(sym, residual_dm);
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Wrote %u bits for selector residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
packed_data.swap(codec.get_encoding_buf());
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug("Wrote a total of %u bits for selector codebook", codec.encode_get_total_bits_written());
console::debug("Wrote %f bits per each selector codebook entry", packed_data.size() * 8.0f / selectors.size());
}
#endif
return true;
}
bool crn_comp::pack_chunks(
uint first_chunk, uint num_chunks,
bool clear_histograms,
symbol_codec* pCodec,
const crnlib::vector<uint>* pColor_endpoint_remap,
const crnlib::vector<uint>* pColor_selector_remap,
const crnlib::vector<uint>* pAlpha_endpoint_remap,
const crnlib::vector<uint>* pAlpha_selector_remap)
{
if (!pCodec)
{
m_chunk_encoding_hist.resize(1 << (3 * cEncodingMapNumChunksPerCode));
if (clear_histograms)
m_chunk_encoding_hist.set_all(0);
if (pColor_endpoint_remap)
{
CRNLIB_ASSERT(pColor_endpoint_remap->size() == m_hvq.get_color_endpoint_codebook_size());
m_endpoint_index_hist[0].resize(pColor_endpoint_remap->size());
if (clear_histograms)
m_endpoint_index_hist[0].set_all(0);
}
if (pColor_selector_remap)
{
CRNLIB_ASSERT(pColor_selector_remap->size() == m_hvq.get_color_selector_codebook_size());
m_selector_index_hist[0].resize(pColor_selector_remap->size());
if (clear_histograms)
m_selector_index_hist[0].set_all(0);
}
if (pAlpha_endpoint_remap)
{
CRNLIB_ASSERT(pAlpha_endpoint_remap->size() == m_hvq.get_alpha_endpoint_codebook_size());
m_endpoint_index_hist[1].resize(pAlpha_endpoint_remap->size());
if (clear_histograms)
m_endpoint_index_hist[1].set_all(0);
}
if (pAlpha_selector_remap)
{
CRNLIB_ASSERT(pAlpha_selector_remap->size() == m_hvq.get_alpha_selector_codebook_size());
m_selector_index_hist[1].resize(pAlpha_selector_remap->size());
if (clear_histograms)
m_selector_index_hist[1].set_all(0);
}
}
uint prev_endpoint_index[cNumComps];
utils::zero_object(prev_endpoint_index);
uint prev_selector_index[cNumComps];
utils::zero_object(prev_selector_index);
uint num_encodings_left = 0;
for (uint chunk_index = first_chunk; chunk_index < (first_chunk + num_chunks); chunk_index++)
{
if (!num_encodings_left)
{
uint index = 0;
for (uint i = 0; i < cEncodingMapNumChunksPerCode; i++)
if ((chunk_index + i) < (first_chunk + num_chunks))
index |= (m_hvq.get_chunk_encoding(chunk_index + i).m_encoding_index << (i * 3));
if (pCodec)
pCodec->encode(index, m_chunk_encoding_dm);
else
m_chunk_encoding_hist.inc_freq(index);
num_encodings_left = cEncodingMapNumChunksPerCode;
}
num_encodings_left--;
const dxt_hc::chunk_encoding& encoding = m_hvq.get_chunk_encoding(chunk_index);
const chunk_detail& details = m_chunk_details[chunk_index];
const uint comp_order[3] = { cAlpha0, cAlpha1, cColor };
for (uint c = 0; c < 3; c++)
{
const uint comp_index = comp_order[c];
if (!m_has_comp[comp_index])
continue;
// endpoints
if (comp_index == cColor)
{
if (pColor_endpoint_remap)
{
for (uint i = 0; i < encoding.m_num_tiles; i++)
{
uint cur_endpoint_index = (*pColor_endpoint_remap)[ m_endpoint_indices[cColor][details.m_first_endpoint_index + i] ];
int endpoint_delta = cur_endpoint_index - prev_endpoint_index[cColor];
int sym = endpoint_delta;
if (sym < 0)
sym += pColor_endpoint_remap->size();
CRNLIB_ASSERT(sym >= 0 && sym < (int)pColor_endpoint_remap->size());
if (!pCodec)
m_endpoint_index_hist[cColor].inc_freq(sym);
else
pCodec->encode(sym, m_endpoint_index_dm[0]);
prev_endpoint_index[cColor] = cur_endpoint_index;
}
}
}
else
{
if (pAlpha_endpoint_remap)
{
for (uint i = 0; i < encoding.m_num_tiles; i++)
{
uint cur_endpoint_index = (*pAlpha_endpoint_remap)[m_endpoint_indices[comp_index][details.m_first_endpoint_index + i]];
int endpoint_delta = cur_endpoint_index - prev_endpoint_index[comp_index];
int sym = endpoint_delta;
if (sym < 0)
sym += pAlpha_endpoint_remap->size();
CRNLIB_ASSERT(sym >= 0 && sym < (int)pAlpha_endpoint_remap->size());
if (!pCodec)
m_endpoint_index_hist[1].inc_freq(sym);
else
pCodec->encode(sym, m_endpoint_index_dm[1]);
prev_endpoint_index[comp_index] = cur_endpoint_index;
}
}
}
} // c
// selectors
for (uint y = 0; y < 2; y++)
{
for (uint x = 0; x < 2; x++)
{
for (uint c = 0; c < 3; c++)
{
const uint comp_index = comp_order[c];
if (!m_has_comp[comp_index])
continue;
if (comp_index == cColor)
{
if (pColor_selector_remap)
{
uint cur_selector_index = (*pColor_selector_remap)[ m_selector_indices[cColor][details.m_first_selector_index + x + y * 2] ];
int selector_delta = cur_selector_index - prev_selector_index[cColor];
int sym = selector_delta;
if (sym < 0)
sym += pColor_selector_remap->size();
CRNLIB_ASSERT(sym >= 0 && sym < (int)pColor_selector_remap->size());
if (!pCodec)
m_selector_index_hist[cColor].inc_freq(sym);
else
pCodec->encode(sym, m_selector_index_dm[cColor]);
prev_selector_index[cColor] = cur_selector_index;
}
}
else if (pAlpha_selector_remap)
{
uint cur_selector_index = (*pAlpha_selector_remap)[ m_selector_indices[comp_index][details.m_first_selector_index + x + y * 2] ];
int selector_delta = cur_selector_index - prev_selector_index[comp_index];
int sym = selector_delta;
if (sym < 0)
sym += pAlpha_selector_remap->size();
CRNLIB_ASSERT(sym >= 0 && sym < (int)pAlpha_selector_remap->size());
if (!pCodec)
m_selector_index_hist[1].inc_freq(sym);
else
pCodec->encode(sym, m_selector_index_dm[1]);
prev_selector_index[comp_index] = cur_selector_index;
}
} // c
} // x
} // y
} // chunk_index
return true;
}
bool crn_comp::pack_chunks_simulation(
uint first_chunk, uint num_chunks,
uint& total_bits,
const crnlib::vector<uint>* pColor_endpoint_remap,
const crnlib::vector<uint>* pColor_selector_remap,
const crnlib::vector<uint>* pAlpha_endpoint_remap,
const crnlib::vector<uint>* pAlpha_selector_remap)
{
if (!pack_chunks(first_chunk, num_chunks, true, NULL, pColor_endpoint_remap, pColor_selector_remap, pAlpha_endpoint_remap, pAlpha_selector_remap))
return false;
symbol_codec codec;
codec.start_encoding(2*1024*1024);
codec.encode_enable_simulation(true);
m_chunk_encoding_dm.init(true, m_chunk_encoding_hist, 16);
for (uint i = 0; i < 2; i++)
{
if (m_endpoint_index_hist[i].size())
{
m_endpoint_index_dm[i].init(true, m_endpoint_index_hist[i], 16);
codec.encode_transmit_static_huffman_data_model(m_endpoint_index_dm[i], false);
}
if (m_selector_index_hist[i].size())
{
m_selector_index_dm[i].init(true, m_selector_index_hist[i], 16);
codec.encode_transmit_static_huffman_data_model(m_selector_index_dm[i], false);
}
}
if (!pack_chunks(first_chunk, num_chunks, false, &codec, pColor_endpoint_remap, pColor_selector_remap, pAlpha_endpoint_remap, pAlpha_selector_remap))
return false;
codec.stop_encoding(false);
total_bits = codec.encode_get_total_bits_written();
return true;
}
void crn_comp::append_vec(crnlib::vector<uint8>& a, const void* p, uint size)
{
if (size)
{
uint ofs = a.size();
a.resize(ofs + size);
memcpy(&a[ofs], p, size);
}
}
void crn_comp::append_vec(crnlib::vector<uint8>& a, const crnlib::vector<uint8>& b)
{
if (!b.empty())
{
uint ofs = a.size();
a.resize(ofs + b.size());
memcpy(&a[ofs], &b[0], b.size());
}
}
#if 0
bool crn_comp::init_chunk_encoding_dm()
{
symbol_histogram hist(1 << (3 * cEncodingMapNumChunksPerCode));
for (uint chunk_index = 0; chunk_index < m_hvq.get_num_chunks(); chunk_index += cEncodingMapNumChunksPerCode)
{
uint index = 0;
for (uint i = 0; i < cEncodingMapNumChunksPerCode; i++)
{
if ((chunk_index + i) >= m_hvq.get_num_chunks())
break;
const dxt_hc::chunk_encoding& encoding = m_hvq.get_chunk_encoding(chunk_index + i);
index |= (encoding.m_encoding_index << (i * 3));
}
hist.inc_freq(index);
}
if (!m_chunk_encoding_dm.init(true, hist, 16))
return false;
return true;
}
#endif
bool crn_comp::alias_images()
{
for (uint face_index = 0; face_index < m_pParams->m_faces; face_index++)
{
for (uint level_index = 0; level_index < m_pParams->m_levels; level_index++)
{
const uint width = math::maximum(1U, m_pParams->m_width >> level_index);
const uint height = math::maximum(1U, m_pParams->m_height >> level_index);
if (!m_pParams->m_pImages[face_index][level_index])
return false;
m_images[face_index][level_index].alias((color_quad_u8*)m_pParams->m_pImages[face_index][level_index], width, height);
}
}
image_utils::conversion_type conv_type = image_utils::get_image_conversion_type_from_crn_format((crn_format)m_pParams->m_format);
if (conv_type != image_utils::cConversion_Invalid)
{
for (uint face_index = 0; face_index < m_pParams->m_faces; face_index++)
{
for (uint level_index = 0; level_index < m_pParams->m_levels; level_index++)
{
image_u8 cooked_image(m_images[face_index][level_index]);
image_utils::convert_image(cooked_image, conv_type);
m_images[face_index][level_index].swap(cooked_image);
}
}
}
m_mip_groups.clear();
m_mip_groups.resize(m_pParams->m_levels);
utils::zero_object(m_levels);
uint mip_group = 0;
uint chunk_index = 0;
uint mip_group_chunk_index = 0; (void)mip_group_chunk_index;
for (uint level_index = 0; level_index < m_pParams->m_levels; level_index++)
{
const uint width = math::maximum(1U, m_pParams->m_width >> level_index);
const uint height = math::maximum(1U, m_pParams->m_height >> level_index);
const uint chunk_width = math::align_up_value(width, cChunkPixelWidth) / cChunkPixelWidth;
const uint chunk_height = math::align_up_value(height, cChunkPixelHeight) / cChunkPixelHeight;
const uint num_chunks = m_pParams->m_faces * chunk_width * chunk_height;
m_mip_groups[mip_group].m_first_chunk = chunk_index;
mip_group_chunk_index = 0;
m_mip_groups[mip_group].m_num_chunks += num_chunks;
m_levels[level_index].m_width = width;
m_levels[level_index].m_height = height;
m_levels[level_index].m_chunk_width = chunk_width;
m_levels[level_index].m_chunk_height = chunk_height;
m_levels[level_index].m_first_chunk = chunk_index;
m_levels[level_index].m_num_chunks = num_chunks;
m_levels[level_index].m_group_index = mip_group;
m_levels[level_index].m_group_first_chunk = 0;
chunk_index += num_chunks;
mip_group++;
}
m_total_chunks = chunk_index;
return true;
}
void crn_comp::append_chunks(const image_u8& img, uint num_chunks_x, uint num_chunks_y, dxt_hc::pixel_chunk_vec& chunks, float weight)
{
for (uint y = 0; y < num_chunks_y; y++)
{
int x_start = 0;
int x_end = num_chunks_x;
int x_dir = 1;
if (y & 1)
{
x_start = num_chunks_x - 1;
x_end = -1;
x_dir = -1;
}
for (int x = x_start; x != x_end; x += x_dir)
{
chunks.resize(chunks.size() + 1);
dxt_hc::pixel_chunk& chunk = chunks.back();
chunk.m_weight = weight;
for (uint cy = 0; cy < cChunkPixelHeight; cy++)
{
uint py = y * cChunkPixelHeight + cy;
py = math::minimum(py, img.get_height() - 1);
for (uint cx = 0; cx < cChunkPixelWidth; cx++)
{
uint px = x * cChunkPixelWidth + cx;
px = math::minimum(px, img.get_width() - 1);
chunk(cx, cy) = img(px, py);
}
}
}
}
}
void crn_comp::create_chunks()
{
m_chunks.reserve(m_total_chunks);
m_chunks.resize(0);
for (uint level = 0; level < m_pParams->m_levels; level++)
{
for (uint face = 0; face < m_pParams->m_faces; face++)
{
if (!face)
{
CRNLIB_ASSERT(m_levels[level].m_first_chunk == m_chunks.size());
}
float mip_weight = math::minimum(12.0f, powf( 1.3f, static_cast<float>(level) ) );
//float mip_weight = 1.0f;
append_chunks(m_images[face][level], m_levels[level].m_chunk_width, m_levels[level].m_chunk_height, m_chunks, mip_weight);
}
}
CRNLIB_ASSERT(m_chunks.size() == m_total_chunks);
}
void crn_comp::clear()
{
m_pParams = NULL;
for (uint f = 0; f < cCRNMaxFaces; f++)
for (uint l = 0; l < cCRNMaxLevels; l++)
m_images[f][l].clear();
utils::zero_object(m_levels);
m_mip_groups.clear();
utils::zero_object(m_has_comp);
m_chunk_details.clear();
for (uint i = 0; i < cNumComps; i++)
{
m_endpoint_indices[i].clear();
m_selector_indices[i].clear();
}
m_total_chunks = 0;
m_chunks.clear();
utils::zero_object(m_crn_header);
m_comp_data.clear();
m_hvq.clear();
m_chunk_encoding_hist.clear();
m_chunk_encoding_dm.clear();
for (uint i = 0; i < 2; i++)
{
m_endpoint_index_hist[i].clear();
m_endpoint_index_dm[i].clear();
m_selector_index_hist[i].clear();
m_selector_index_dm[i].clear();
}
for (uint i = 0; i < cCRNMaxLevels; i++)
m_packed_chunks[i].clear();
m_packed_data_models.clear();
m_packed_color_endpoints.clear();
m_packed_color_selectors.clear();
m_packed_alpha_endpoints.clear();
m_packed_alpha_selectors.clear();
}
bool crn_comp::quantize_chunks()
{
dxt_hc::params params;
params.m_adaptive_tile_alpha_psnr_derating = m_pParams->m_crn_adaptive_tile_alpha_psnr_derating;
params.m_adaptive_tile_color_psnr_derating = m_pParams->m_crn_adaptive_tile_color_psnr_derating;
if (m_pParams->m_flags & cCRNCompFlagManualPaletteSizes)
{
params.m_color_endpoint_codebook_size = math::clamp<int>(m_pParams->m_crn_color_endpoint_palette_size, cCRNMinPaletteSize, cCRNMaxPaletteSize);
params.m_color_selector_codebook_size = math::clamp<int>(m_pParams->m_crn_color_selector_palette_size, cCRNMinPaletteSize, cCRNMaxPaletteSize);
params.m_alpha_endpoint_codebook_size = math::clamp<int>(m_pParams->m_crn_alpha_endpoint_palette_size, cCRNMinPaletteSize, cCRNMaxPaletteSize);
params.m_alpha_selector_codebook_size = math::clamp<int>(m_pParams->m_crn_alpha_selector_palette_size, cCRNMinPaletteSize, cCRNMaxPaletteSize);
}
else
{
uint max_codebook_entries = ((m_pParams->m_width + 3) / 4) * ((m_pParams->m_height + 3) / 4);
max_codebook_entries = math::clamp<uint>(max_codebook_entries, cCRNMinPaletteSize, cCRNMaxPaletteSize);
float quality = math::clamp<float>((float)m_pParams->m_quality_level / cCRNMaxQualityLevel, 0.0f, 1.0f);
float color_quality_power_mul = 1.0f;
float alpha_quality_power_mul = 1.0f;
if (m_pParams->m_format == cCRNFmtDXT5_CCxY)
{
color_quality_power_mul = 3.5f;
alpha_quality_power_mul = .35f;
params.m_adaptive_tile_color_psnr_derating = 5.0f;
}
else if (m_pParams->m_format == cCRNFmtDXT5)
color_quality_power_mul = .75f;
float color_endpoint_quality = powf(quality, 1.8f * color_quality_power_mul);
float color_selector_quality = powf(quality, 1.65f * color_quality_power_mul);
params.m_color_endpoint_codebook_size = math::clamp<uint>(math::float_to_uint(.5f + math::lerp<float>(math::maximum<float>(64, cCRNMinPaletteSize), (float)max_codebook_entries, color_endpoint_quality)), cCRNMinPaletteSize, cCRNMaxPaletteSize);
params.m_color_selector_codebook_size = math::clamp<uint>(math::float_to_uint(.5f + math::lerp<float>(math::maximum<float>(96, cCRNMinPaletteSize), (float)max_codebook_entries, color_selector_quality)), cCRNMinPaletteSize, cCRNMaxPaletteSize);
float alpha_endpoint_quality = powf(quality, 2.1f * alpha_quality_power_mul);
float alpha_selector_quality = powf(quality, 1.65f * alpha_quality_power_mul);
params.m_alpha_endpoint_codebook_size = math::clamp<uint>(math::float_to_uint(.5f + math::lerp<float>(math::maximum<float>(24, cCRNMinPaletteSize), (float)max_codebook_entries, alpha_endpoint_quality)), cCRNMinPaletteSize, cCRNMaxPaletteSize);;
params.m_alpha_selector_codebook_size = math::clamp<uint>(math::float_to_uint(.5f + math::lerp<float>(math::maximum<float>(48, cCRNMinPaletteSize), (float)max_codebook_entries, alpha_selector_quality)), cCRNMinPaletteSize, cCRNMaxPaletteSize);;
}
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug("Color endpoints: %u", params.m_color_endpoint_codebook_size);
console::debug("Color selectors: %u", params.m_color_selector_codebook_size);
console::debug("Alpha endpoints: %u", params.m_alpha_endpoint_codebook_size);
console::debug("Alpha selectors: %u", params.m_alpha_selector_codebook_size);
}
params.m_hierarchical = (m_pParams->m_flags & cCRNCompFlagHierarchical) != 0;
params.m_perceptual = (m_pParams->m_flags & cCRNCompFlagPerceptual) != 0;
params.m_pProgress_func = m_pParams->m_pProgress_func;
params.m_pProgress_func_data = m_pParams->m_pProgress_func_data;
switch (m_pParams->m_format)
{
case cCRNFmtDXT1:
{
params.m_format = cDXT1;
m_has_comp[cColor] = true;
break;
}
case cCRNFmtDXT3:
{
m_has_comp[cAlpha0] = true;
return false;
}
case cCRNFmtDXT5:
{
params.m_format = cDXT5;
params.m_alpha_component_indices[0] = m_pParams->m_alpha_component;
m_has_comp[cColor] = true;
m_has_comp[cAlpha0] = true;
break;
}
case cCRNFmtDXT5_CCxY:
{
params.m_format = cDXT5;
params.m_alpha_component_indices[0] = 3;
m_has_comp[cColor] = true;
m_has_comp[cAlpha0] = true;
params.m_perceptual = false;
//params.m_adaptive_tile_color_alpha_weighting_ratio = 1.0f;
params.m_adaptive_tile_color_alpha_weighting_ratio = 1.5f;
break;
}
case cCRNFmtDXT5_xGBR:
case cCRNFmtDXT5_AGBR:
case cCRNFmtDXT5_xGxR:
{
params.m_format = cDXT5;
params.m_alpha_component_indices[0] = 3;
m_has_comp[cColor] = true;
m_has_comp[cAlpha0] = true;
params.m_perceptual = false;
break;
}
case cCRNFmtDXN_XY:
{
params.m_format = cDXN_XY;
params.m_alpha_component_indices[0] = 0;
params.m_alpha_component_indices[1] = 1;
m_has_comp[cAlpha0] = true;
m_has_comp[cAlpha1] = true;
params.m_perceptual = false;
break;
}
case cCRNFmtDXN_YX:
{
params.m_format = cDXN_YX;
params.m_alpha_component_indices[0] = 1;
params.m_alpha_component_indices[1] = 0;
m_has_comp[cAlpha0] = true;
m_has_comp[cAlpha1] = true;
params.m_perceptual = false;
break;
}
case cCRNFmtDXT5A:
{
params.m_format = cDXT5A;
params.m_alpha_component_indices[0] = m_pParams->m_alpha_component;
m_has_comp[cAlpha0] = true;
params.m_perceptual = false;
break;
}
case cCRNFmtETC1:
{
console::warning("crn_comp::quantize_chunks: This class does not support ETC1");
return false;
}
default:
{
return false;
}
}
params.m_debugging = (m_pParams->m_flags & cCRNCompFlagDebugging) != 0;
params.m_num_levels = m_pParams->m_levels;
for (uint i = 0; i < m_pParams->m_levels; i++)
{
params.m_levels[i].m_first_chunk = m_levels[i].m_first_chunk;
params.m_levels[i].m_num_chunks = m_levels[i].m_num_chunks;
}
if (!m_hvq.compress(params, m_total_chunks, &m_chunks[0], m_task_pool))
return false;
#if CRNLIB_CREATE_DEBUG_IMAGES
if (params.m_debugging)
{
const dxt_hc::pixel_chunk_vec& pixel_chunks = m_hvq.get_compressed_chunk_pixels_final();
image_u8 img;
dxt_hc::create_debug_image_from_chunks((m_pParams->m_width+7)>>3, (m_pParams->m_height+7)>>3, pixel_chunks, &m_hvq.get_chunk_encoding_vec(), img, true, -1);
image_utils::write_to_file("quantized_chunks.tga", img);
}
#endif
return true;
}
void crn_comp::create_chunk_indices()
{
m_chunk_details.resize(m_total_chunks);
for (uint i = 0; i < cNumComps; i++)
{
m_endpoint_indices[i].clear();
m_selector_indices[i].clear();
}
for (uint chunk_index = 0; chunk_index < m_total_chunks; chunk_index++)
{
const dxt_hc::chunk_encoding& chunk_encoding = m_hvq.get_chunk_encoding(chunk_index);
for (uint i = 0; i < cNumComps; i++)
{
if (m_has_comp[i])
{
m_chunk_details[chunk_index].m_first_endpoint_index = m_endpoint_indices[i].size();
m_chunk_details[chunk_index].m_first_selector_index = m_selector_indices[i].size();
break;
}
}
for (uint i = 0; i < cNumComps; i++)
{
if (!m_has_comp[i])
continue;
for (uint tile_index = 0; tile_index < chunk_encoding.m_num_tiles; tile_index++)
m_endpoint_indices[i].push_back(chunk_encoding.m_endpoint_indices[i][tile_index]);
for (uint y = 0; y < cChunkBlockHeight; y++)
for (uint x = 0; x < cChunkBlockWidth; x++)
m_selector_indices[i].push_back(chunk_encoding.m_selector_indices[i][y][x]);
}
}
}
struct optimize_color_endpoint_codebook_params
{
crnlib::vector<uint>* m_pTrial_color_endpoint_remap;
uint m_iter_index;
uint m_max_iter_index;
};
void crn_comp::optimize_color_endpoint_codebook_task(uint64 data, void* pData_ptr)
{
data;
optimize_color_endpoint_codebook_params* pParams = reinterpret_cast<optimize_color_endpoint_codebook_params*>(pData_ptr);
if (pParams->m_iter_index == pParams->m_max_iter_index)
{
sort_color_endpoint_codebook(*pParams->m_pTrial_color_endpoint_remap, m_hvq.get_color_endpoint_vec());
}
else
{
float f = pParams->m_iter_index / static_cast<float>(pParams->m_max_iter_index - 1);
create_zeng_reorder_table(
m_hvq.get_color_endpoint_codebook_size(),
m_endpoint_indices[cColor].size(),
&m_endpoint_indices[cColor][0],
*pParams->m_pTrial_color_endpoint_remap,
pParams->m_iter_index ? color_endpoint_similarity_func : NULL,
&m_hvq,
f);
}
crnlib_delete(pParams);
}
bool crn_comp::optimize_color_endpoint_codebook(crnlib::vector<uint>& remapping)
{
if (m_pParams->m_flags & cCRNCompFlagQuick)
{
remapping.resize(m_hvq.get_color_endpoint_vec().size());
for (uint i = 0; i < m_hvq.get_color_endpoint_vec().size(); i++)
remapping[i] = i;
if (!pack_color_endpoints(m_packed_color_endpoints, remapping, m_endpoint_indices[cColor], 0))
return false;
return true;
}
const uint cMaxEndpointRemapIters = 3;
uint best_bits = UINT_MAX;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("----- Begin optimization of color endpoint codebook");
#endif
crnlib::vector<uint> trial_color_endpoint_remaps[cMaxEndpointRemapIters + 1];
for (uint i = 0; i <= cMaxEndpointRemapIters; i++)
{
optimize_color_endpoint_codebook_params* pParams = crnlib_new<optimize_color_endpoint_codebook_params>();
pParams->m_iter_index = i;
pParams->m_max_iter_index = cMaxEndpointRemapIters;
pParams->m_pTrial_color_endpoint_remap = &trial_color_endpoint_remaps[i];
m_task_pool.queue_object_task(this, &crn_comp::optimize_color_endpoint_codebook_task, 0, pParams);
}
m_task_pool.join();
for (uint i = 0; i <= cMaxEndpointRemapIters; i++)
{
if (!update_progress(20, i, cMaxEndpointRemapIters+1))
return false;
crnlib::vector<uint>& trial_color_endpoint_remap = trial_color_endpoint_remaps[i];
crnlib::vector<uint8> packed_data;
if (!pack_color_endpoints(packed_data, trial_color_endpoint_remap, m_endpoint_indices[cColor], i))
return false;
uint total_packed_chunk_bits;
if (!pack_chunks_simulation(0, m_total_chunks, total_packed_chunk_bits, &trial_color_endpoint_remap, NULL, NULL, NULL))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
m_packed_color_endpoints.swap(packed_data);
remapping.swap(trial_color_endpoint_remap);
best_bits = total_bits;
}
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("End optimization of color endpoint codebook");
#endif
return true;
}
struct optimize_color_selector_codebook_params
{
crnlib::vector<uint>* m_pTrial_color_selector_remap;
uint m_iter_index;
uint m_max_iter_index;
};
void crn_comp::optimize_color_selector_codebook_task(uint64 data, void* pData_ptr)
{
data;
optimize_color_selector_codebook_params* pParams = reinterpret_cast<optimize_color_selector_codebook_params*>(pData_ptr);
if (pParams->m_iter_index == pParams->m_max_iter_index)
{
sort_selector_codebook(*pParams->m_pTrial_color_selector_remap, m_hvq.get_color_selectors_vec(), g_dxt1_to_linear);
}
else
{
float f = pParams->m_iter_index / static_cast<float>(pParams->m_max_iter_index - 1);
create_zeng_reorder_table(
m_hvq.get_color_selector_codebook_size(),
m_selector_indices[cColor].size(),
&m_selector_indices[cColor][0],
*pParams->m_pTrial_color_selector_remap,
pParams->m_iter_index ? color_selector_similarity_func : NULL,
(void*)&m_hvq.get_color_selectors_vec(),
f);
}
crnlib_delete(pParams);
}
bool crn_comp::optimize_color_selector_codebook(crnlib::vector<uint>& remapping)
{
if (m_pParams->m_flags & cCRNCompFlagQuick)
{
remapping.resize(m_hvq.get_color_selectors_vec().size());
for (uint i = 0; i < m_hvq.get_color_selectors_vec().size(); i++)
remapping[i] = i;
if (!pack_selectors(
m_packed_color_selectors,
m_selector_indices[cColor],
m_hvq.get_color_selectors_vec(),
remapping,
3,
g_dxt1_to_linear, 0))
{
return false;
}
return true;
}
const uint cMaxSelectorRemapIters = 3;
uint best_bits = UINT_MAX;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("----- Begin optimization of color selector codebook");
#endif
crnlib::vector<uint> trial_color_selector_remaps[cMaxSelectorRemapIters + 1];
for (uint i = 0; i <= cMaxSelectorRemapIters; i++)
{
optimize_color_selector_codebook_params* pParams = crnlib_new<optimize_color_selector_codebook_params>();
pParams->m_iter_index = i;
pParams->m_max_iter_index = cMaxSelectorRemapIters;
pParams->m_pTrial_color_selector_remap = &trial_color_selector_remaps[i];
m_task_pool.queue_object_task(this, &crn_comp::optimize_color_selector_codebook_task, 0, pParams);
}
m_task_pool.join();
for (uint i = 0; i <= cMaxSelectorRemapIters; i++)
{
if (!update_progress(21, i, cMaxSelectorRemapIters+1))
return false;
crnlib::vector<uint>& trial_color_selector_remap = trial_color_selector_remaps[i];
crnlib::vector<uint8> packed_data;
if (!pack_selectors(
packed_data,
m_selector_indices[cColor],
m_hvq.get_color_selectors_vec(),
trial_color_selector_remap,
3,
g_dxt1_to_linear, i))
{
return false;
}
uint total_packed_chunk_bits;
if (!pack_chunks_simulation(0, m_total_chunks, total_packed_chunk_bits, NULL, &trial_color_selector_remap, NULL, NULL))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
m_packed_color_selectors.swap(packed_data);
remapping.swap(trial_color_selector_remap);
best_bits = total_bits;
}
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("End optimization of color selector codebook");
#endif
return true;
}
struct optimize_alpha_endpoint_codebook_params
{
crnlib::vector<uint>* m_pAlpha_indices;
crnlib::vector<uint>* m_pTrial_alpha_endpoint_remap;
uint m_iter_index;
uint m_max_iter_index;
};
void crn_comp::optimize_alpha_endpoint_codebook_task(uint64 data, void* pData_ptr)
{
data;
optimize_alpha_endpoint_codebook_params* pParams = reinterpret_cast<optimize_alpha_endpoint_codebook_params*>(pData_ptr);
if (pParams->m_iter_index == pParams->m_max_iter_index)
{
sort_alpha_endpoint_codebook(*pParams->m_pTrial_alpha_endpoint_remap, m_hvq.get_alpha_endpoint_vec());
}
else
{
float f = pParams->m_iter_index / static_cast<float>(pParams->m_max_iter_index - 1);
create_zeng_reorder_table(
m_hvq.get_alpha_endpoint_codebook_size(),
pParams->m_pAlpha_indices->size(),
&(*pParams->m_pAlpha_indices)[0],
*pParams->m_pTrial_alpha_endpoint_remap,
pParams->m_iter_index ? alpha_endpoint_similarity_func : NULL,
&m_hvq,
f);
}
crnlib_delete(pParams);
}
bool crn_comp::optimize_alpha_endpoint_codebook(crnlib::vector<uint>& remapping)
{
crnlib::vector<uint> alpha_indices;
alpha_indices.reserve(m_endpoint_indices[cAlpha0].size() + m_endpoint_indices[cAlpha1].size());
for (uint i = 0; i < m_endpoint_indices[cAlpha0].size(); i++)
alpha_indices.push_back(m_endpoint_indices[cAlpha0][i]);
for (uint i = 0; i < m_endpoint_indices[cAlpha1].size(); i++)
alpha_indices.push_back(m_endpoint_indices[cAlpha1][i]);
if (m_pParams->m_flags & cCRNCompFlagQuick)
{
remapping.resize(m_hvq.get_alpha_endpoint_vec().size());
for (uint i = 0; i < m_hvq.get_alpha_endpoint_vec().size(); i++)
remapping[i] = i;
if (!pack_alpha_endpoints(m_packed_alpha_endpoints, remapping, alpha_indices, 0))
return false;
return true;
}
const uint cMaxEndpointRemapIters = 3;
uint best_bits = UINT_MAX;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("----- Begin optimization of alpha endpoint codebook");
#endif
crnlib::vector<uint> trial_alpha_endpoint_remaps[cMaxEndpointRemapIters + 1];
for (uint i = 0; i <= cMaxEndpointRemapIters; i++)
{
optimize_alpha_endpoint_codebook_params* pParams = crnlib_new<optimize_alpha_endpoint_codebook_params>();
pParams->m_pAlpha_indices = &alpha_indices;
pParams->m_iter_index = i;
pParams->m_max_iter_index = cMaxEndpointRemapIters;
pParams->m_pTrial_alpha_endpoint_remap = &trial_alpha_endpoint_remaps[i];
m_task_pool.queue_object_task(this, &crn_comp::optimize_alpha_endpoint_codebook_task, 0, pParams);
}
m_task_pool.join();
for (uint i = 0; i <= cMaxEndpointRemapIters; i++)
{
if (!update_progress(22, i, cMaxEndpointRemapIters+1))
return false;
crnlib::vector<uint>& trial_alpha_endpoint_remap = trial_alpha_endpoint_remaps[i];
crnlib::vector<uint8> packed_data;
if (!pack_alpha_endpoints(packed_data, trial_alpha_endpoint_remap, alpha_indices, i))
return false;
uint total_packed_chunk_bits;
if (!pack_chunks_simulation(0, m_total_chunks, total_packed_chunk_bits, NULL, NULL, &trial_alpha_endpoint_remap, NULL))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
m_packed_alpha_endpoints.swap(packed_data);
remapping.swap(trial_alpha_endpoint_remap);
best_bits = total_bits;
}
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("End optimization of alpha endpoint codebook");
#endif
return true;
}
struct optimize_alpha_selector_codebook_params
{
crnlib::vector<uint>* m_pAlpha_indices;
crnlib::vector<uint>* m_pTrial_alpha_selector_remap;
uint m_iter_index;
uint m_max_iter_index;
};
void crn_comp::optimize_alpha_selector_codebook_task(uint64 data, void* pData_ptr)
{
data;
optimize_alpha_selector_codebook_params* pParams = reinterpret_cast<optimize_alpha_selector_codebook_params*>(pData_ptr);
if (pParams->m_iter_index == pParams->m_max_iter_index)
{
sort_selector_codebook(*pParams->m_pTrial_alpha_selector_remap, m_hvq.get_alpha_selectors_vec(), g_dxt5_to_linear);
}
else
{
float f = pParams->m_iter_index / static_cast<float>(pParams->m_max_iter_index - 1);
create_zeng_reorder_table(
m_hvq.get_alpha_selector_codebook_size(),
pParams->m_pAlpha_indices->size(),
&(*pParams->m_pAlpha_indices)[0],
*pParams->m_pTrial_alpha_selector_remap,
pParams->m_iter_index ? alpha_selector_similarity_func : NULL,
(void*)&m_hvq.get_alpha_selectors_vec(),
f);
}
}
bool crn_comp::optimize_alpha_selector_codebook(crnlib::vector<uint>& remapping)
{
crnlib::vector<uint> alpha_indices;
alpha_indices.reserve(m_selector_indices[cAlpha0].size() + m_selector_indices[cAlpha1].size());
for (uint i = 0; i < m_selector_indices[cAlpha0].size(); i++)
alpha_indices.push_back(m_selector_indices[cAlpha0][i]);
for (uint i = 0; i < m_selector_indices[cAlpha1].size(); i++)
alpha_indices.push_back(m_selector_indices[cAlpha1][i]);
if (m_pParams->m_flags & cCRNCompFlagQuick)
{
remapping.resize(m_hvq.get_alpha_selectors_vec().size());
for (uint i = 0; i < m_hvq.get_alpha_selectors_vec().size(); i++)
remapping[i] = i;
if (!pack_selectors(
m_packed_alpha_selectors,
alpha_indices,
m_hvq.get_alpha_selectors_vec(),
remapping,
7,
g_dxt5_to_linear, 0))
{
return false;
}
return true;
}
const uint cMaxSelectorRemapIters = 3;
uint best_bits = UINT_MAX;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("----- Begin optimization of alpha selector codebook");
#endif
crnlib::vector<uint> trial_alpha_selector_remaps[cMaxSelectorRemapIters + 1];
for (uint i = 0; i <= cMaxSelectorRemapIters; i++)
{
optimize_alpha_selector_codebook_params* pParams = crnlib_new<optimize_alpha_selector_codebook_params>();
pParams->m_pAlpha_indices = &alpha_indices;
pParams->m_iter_index = i;
pParams->m_max_iter_index = cMaxSelectorRemapIters;
pParams->m_pTrial_alpha_selector_remap = &trial_alpha_selector_remaps[i];
m_task_pool.queue_object_task(this, &crn_comp::optimize_alpha_selector_codebook_task, 0, pParams);
}
m_task_pool.join();
for (uint i = 0; i <= cMaxSelectorRemapIters; i++)
{
if (!update_progress(23, i, cMaxSelectorRemapIters+1))
return false;
crnlib::vector<uint>& trial_alpha_selector_remap = trial_alpha_selector_remaps[i];
crnlib::vector<uint8> packed_data;
if (!pack_selectors(
packed_data,
alpha_indices,
m_hvq.get_alpha_selectors_vec(),
trial_alpha_selector_remap,
7,
g_dxt5_to_linear, i))
{
return false;
}
uint total_packed_chunk_bits;
if (!pack_chunks_simulation(0, m_total_chunks, total_packed_chunk_bits, NULL, NULL, NULL, &trial_alpha_selector_remap))
return false;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
m_packed_alpha_selectors.swap(packed_data);
remapping.swap(trial_alpha_selector_remap);
best_bits = total_bits;
}
}
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug("End optimization of alpha selector codebook");
#endif
return true;
}
bool crn_comp::pack_data_models()
{
symbol_codec codec;
codec.start_encoding(1024*1024);
if (!codec.encode_transmit_static_huffman_data_model(m_chunk_encoding_dm, false))
return false;
for (uint i = 0; i < 2; i++)
{
if (m_endpoint_index_dm[i].get_total_syms())
{
if (!codec.encode_transmit_static_huffman_data_model(m_endpoint_index_dm[i], false))
return false;
}
if (m_selector_index_dm[i].get_total_syms())
{
if (!codec.encode_transmit_static_huffman_data_model(m_selector_index_dm[i], false))
return false;
}
}
codec.stop_encoding(false);
m_packed_data_models.swap(codec.get_encoding_buf());
return true;
}
bool crn_comp::create_comp_data()
{
utils::zero_object(m_crn_header);
m_crn_header.m_width = static_cast<uint16>(m_pParams->m_width);
m_crn_header.m_height = static_cast<uint16>(m_pParams->m_height);
m_crn_header.m_levels = static_cast<uint8>(m_pParams->m_levels);
m_crn_header.m_faces = static_cast<uint8>(m_pParams->m_faces);
m_crn_header.m_format = static_cast<uint8>(m_pParams->m_format);
m_crn_header.m_userdata0 = m_pParams->m_userdata0;
m_crn_header.m_userdata1 = m_pParams->m_userdata1;
m_comp_data.clear();
m_comp_data.reserve(2*1024*1024);
append_vec(m_comp_data, &m_crn_header, sizeof(m_crn_header));
// tack on the rest of the variable size m_level_ofs array
m_comp_data.resize( m_comp_data.size() + sizeof(m_crn_header.m_level_ofs[0]) * (m_pParams->m_levels - 1) );
if (m_packed_color_endpoints.size())
{
m_crn_header.m_color_endpoints.m_num = static_cast<uint16>(m_hvq.get_color_endpoint_codebook_size());
m_crn_header.m_color_endpoints.m_size = m_packed_color_endpoints.size();
m_crn_header.m_color_endpoints.m_ofs = m_comp_data.size();
append_vec(m_comp_data, m_packed_color_endpoints);
}
if (m_packed_color_selectors.size())
{
m_crn_header.m_color_selectors.m_num = static_cast<uint16>(m_hvq.get_color_selector_codebook_size());
m_crn_header.m_color_selectors.m_size = m_packed_color_selectors.size();
m_crn_header.m_color_selectors.m_ofs = m_comp_data.size();
append_vec(m_comp_data, m_packed_color_selectors);
}
if (m_packed_alpha_endpoints.size())
{
m_crn_header.m_alpha_endpoints.m_num = static_cast<uint16>(m_hvq.get_alpha_endpoint_codebook_size());
m_crn_header.m_alpha_endpoints.m_size = m_packed_alpha_endpoints.size();
m_crn_header.m_alpha_endpoints.m_ofs = m_comp_data.size();
append_vec(m_comp_data, m_packed_alpha_endpoints);
}
if (m_packed_alpha_selectors.size())
{
m_crn_header.m_alpha_selectors.m_num = static_cast<uint16>(m_hvq.get_alpha_selector_codebook_size());
m_crn_header.m_alpha_selectors.m_size = m_packed_alpha_selectors.size();
m_crn_header.m_alpha_selectors.m_ofs = m_comp_data.size();
append_vec(m_comp_data, m_packed_alpha_selectors);
}
m_crn_header.m_tables_ofs = m_comp_data.size();
m_crn_header.m_tables_size = m_packed_data_models.size();
append_vec(m_comp_data, m_packed_data_models);
uint level_ofs[cCRNMaxLevels];
for (uint i = 0; i < m_mip_groups.size(); i++)
{
level_ofs[i] = m_comp_data.size();
append_vec(m_comp_data, m_packed_chunks[i]);
}
crnd::crn_header& dst_header = *(crnd::crn_header*)&m_comp_data[0];
// don't change the m_comp_data vector - or dst_header will be invalidated!
memcpy(&dst_header, &m_crn_header, sizeof(dst_header));
for (uint i = 0; i < m_mip_groups.size(); i++)
dst_header.m_level_ofs[i] = level_ofs[i];
const uint actual_header_size = sizeof(crnd::crn_header) + sizeof(dst_header.m_level_ofs[0]) * (m_mip_groups.size() - 1);
dst_header.m_sig = crnd::crn_header::cCRNSigValue;
dst_header.m_data_size = m_comp_data.size();
dst_header.m_data_crc16 = crc16(&m_comp_data[actual_header_size], m_comp_data.size() - actual_header_size);
dst_header.m_header_size = actual_header_size;
dst_header.m_header_crc16 = crc16(&dst_header.m_data_size, actual_header_size - (uint)((uint8*)&dst_header.m_data_size - (uint8*)&dst_header));
return true;
}
bool crn_comp::update_progress(uint phase_index, uint subphase_index, uint subphase_total)
{
if (!m_pParams->m_pProgress_func)
return true;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
return true;
#endif
return (*m_pParams->m_pProgress_func)(phase_index, cTotalCompressionPhases, subphase_index, subphase_total, m_pParams->m_pProgress_func_data) != 0;
}
bool crn_comp::compress_internal()
{
if (!alias_images())
return false;
create_chunks();
if (!quantize_chunks())
return false;
create_chunk_indices();
crnlib::vector<uint> endpoint_remap[2];
crnlib::vector<uint> selector_remap[2];
if (m_has_comp[cColor])
{
if (!optimize_color_endpoint_codebook(endpoint_remap[0]))
return false;
if (!optimize_color_selector_codebook(selector_remap[0]))
return false;
}
if (m_has_comp[cAlpha0])
{
if (!optimize_alpha_endpoint_codebook(endpoint_remap[1]))
return false;
if (!optimize_alpha_selector_codebook(selector_remap[1]))
return false;
}
m_chunk_encoding_hist.clear();
for (uint i = 0; i < 2; i++)
{
m_endpoint_index_hist[i].clear();
m_endpoint_index_dm[i].clear();
m_selector_index_hist[i].clear();
m_selector_index_dm[i].clear();
}
for (uint pass = 0; pass < 2; pass++)
{
for (uint mip_group = 0; mip_group < m_mip_groups.size(); mip_group++)
{
symbol_codec codec;
codec.start_encoding(2*1024*1024);
if (!pack_chunks(
m_mip_groups[mip_group].m_first_chunk, m_mip_groups[mip_group].m_num_chunks,
!pass && !mip_group, pass ? &codec : NULL,
m_has_comp[cColor] ? &endpoint_remap[0] : NULL, m_has_comp[cColor] ? &selector_remap[0] : NULL,
m_has_comp[cAlpha0] ? &endpoint_remap[1] : NULL, m_has_comp[cAlpha0] ? &selector_remap[1] : NULL))
{
return false;
}
codec.stop_encoding(false);
if (pass)
m_packed_chunks[mip_group].swap(codec.get_encoding_buf());
}
if (!pass)
{
m_chunk_encoding_dm.init(true, m_chunk_encoding_hist, 16);
for (uint i = 0; i < 2; i++)
{
if (m_endpoint_index_hist[i].size())
m_endpoint_index_dm[i].init(true, m_endpoint_index_hist[i], 16);
if (m_selector_index_hist[i].size())
m_selector_index_dm[i].init(true, m_selector_index_hist[i], 16);
}
}
}
if (!pack_data_models())
return false;
if (!create_comp_data())
return false;
if (!update_progress(24, 1, 1))
return false;
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
crnlib_print_mem_stats();
}
return true;
}
bool crn_comp::compress_init(const crn_comp_params& params)
{
params;
return true;
}
bool crn_comp::compress_pass(const crn_comp_params& params, float *pEffective_bitrate)
{
clear();
if (pEffective_bitrate) *pEffective_bitrate = 0.0f;
m_pParams = &params;
if ((math::minimum(m_pParams->m_width, m_pParams->m_height) < 1) || (math::maximum(m_pParams->m_width, m_pParams->m_height) > cCRNMaxLevelResolution))
return false;
if (!m_task_pool.init(params.m_num_helper_threads))
return false;
bool status = compress_internal();
m_task_pool.deinit();
if ((status) && (pEffective_bitrate))
{
uint total_pixels = 0;
for (uint f = 0; f < m_pParams->m_faces; f++)
for (uint l = 0; l < m_pParams->m_levels; l++)
total_pixels += m_images[f][l].get_total_pixels();
*pEffective_bitrate = (m_comp_data.size() * 8.0f) / total_pixels;
}
return status;
}
void crn_comp::compress_deinit()
{
}
} // namespace crnlib