mirror of https://github.com/axmolengine/axmol.git
2266 lines
79 KiB
C++
2266 lines
79 KiB
C++
// SPDX-License-Identifier: Apache-2.0
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright 2011-2021 Arm Limited
|
|
//
|
|
// 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.
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* @brief Functions and data declarations.
|
|
*/
|
|
|
|
#ifndef ASTCENC_INTERNAL_INCLUDED
|
|
#define ASTCENC_INTERNAL_INCLUDED
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <condition_variable>
|
|
#include <functional>
|
|
#include <mutex>
|
|
#include <type_traits>
|
|
|
|
#include "astcenc.h"
|
|
#include "astcenc_mathlib.h"
|
|
#include "astcenc_vecmathlib.h"
|
|
|
|
/**
|
|
* @brief Make a promise to the compiler's optimizer.
|
|
*
|
|
* A promise is an expression that the optimizer is can assume is true for to help it generate
|
|
* faster code. Common use cases for this are to promise that a for loop will iterate more than
|
|
* once, or that the loop iteration count is a multiple of a vector length, which avoids pre-loop
|
|
* checks and can avoid loop tails if loops are unrolled by the auto-vectorizer.
|
|
*/
|
|
#if defined(NDEBUG)
|
|
#if !defined(__clang__) && defined(_MSC_VER)
|
|
#define promise(cond) __assume(cond)
|
|
#elif defined(__clang__)
|
|
#if __has_builtin(__builtin_assume)
|
|
#define promise(cond) __builtin_assume(cond)
|
|
#elif __has_builtin(__builtin_unreachable)
|
|
#define promise(cond) if(!(cond)) { __builtin_unreachable(); }
|
|
#else
|
|
#define promise(cond)
|
|
#endif
|
|
#else // Assume GCC
|
|
#define promise(cond) if(!(cond)) { __builtin_unreachable(); }
|
|
#endif
|
|
#else
|
|
#define promise(cond) assert(cond);
|
|
#endif
|
|
|
|
/* ============================================================================
|
|
Constants
|
|
============================================================================ */
|
|
/** @brief The maximum number of components a block can support. */
|
|
static constexpr unsigned int BLOCK_MAX_COMPONENTS { 4 };
|
|
|
|
/** @brief The maximum number of partitions a block can support. */
|
|
static constexpr unsigned int BLOCK_MAX_PARTITIONS { 4 };
|
|
|
|
/** @brief The number of partitionings, per partition count, suported by the ASTC format. */
|
|
static constexpr unsigned int BLOCK_MAX_PARTITIONINGS { 1024 };
|
|
|
|
/** @brief The maximum number of texels a block can support (6x6x6 block). */
|
|
static constexpr unsigned int BLOCK_MAX_TEXELS { 216 };
|
|
|
|
/** @brief The maximum number of weights used during partition selection for texel clustering. */
|
|
static constexpr uint8_t BLOCK_MAX_KMEANS_TEXELS { 64 };
|
|
|
|
/** @brief The maximum number of weights a block can support. */
|
|
static constexpr unsigned int BLOCK_MAX_WEIGHTS { 64 };
|
|
|
|
/** @brief The minimum number of weight bits a candidate encoding must encode. */
|
|
static constexpr unsigned int BLOCK_MIN_WEIGHT_BITS { 24 };
|
|
|
|
/** @brief The maximum number of weight bits a candidate encoding can encode. */
|
|
static constexpr unsigned int BLOCK_MAX_WEIGHT_BITS { 96 };
|
|
|
|
/** @brief The index indicating a bad (unused) block mode in the remap array. */
|
|
static constexpr uint16_t BLOCK_BAD_BLOCK_MODE { 0xFFFFu };
|
|
|
|
/** @brief The number of partition index bits supported by the ASTC format . */
|
|
static constexpr unsigned int PARTITION_INDEX_BITS { 10 };
|
|
|
|
/** @brief The offset of the plane 2 weights in shared weight arrays. */
|
|
static constexpr unsigned int WEIGHTS_PLANE2_OFFSET { BLOCK_MAX_WEIGHTS / 2 };
|
|
|
|
/** @brief The sum of quantized weights for one texel. */
|
|
static constexpr float WEIGHTS_TEXEL_SUM { 16.0f };
|
|
|
|
/** @brief The number of block modes suported by the ASTC format. */
|
|
static constexpr unsigned int WEIGHTS_MAX_BLOCK_MODES { 2048 };
|
|
|
|
/** @brief The number of weight grid decimation modes suported by the ASTC format. */
|
|
static constexpr unsigned int WEIGHTS_MAX_DECIMATION_MODES { 87 };
|
|
|
|
/** @brief The high default error used to initialize error trackers. */
|
|
static constexpr float ERROR_CALC_DEFAULT { 1e30f };
|
|
|
|
/**
|
|
* @brief The max texel count in a block which can try the one partition fast path.
|
|
*
|
|
* This is enabled for 4x4 and 5x4 block sizes.
|
|
*/
|
|
static constexpr unsigned int TUNE_MAX_TEXELS_MODE0_FASTPATH { 24 };
|
|
|
|
/**
|
|
* @brief The maximum number of candidate encodings tested for each encoding mode..
|
|
*
|
|
* This can be dynamically reduced by the compression quality preset.
|
|
*/
|
|
static constexpr unsigned int TUNE_MAX_TRIAL_CANDIDATES { 4 };
|
|
|
|
|
|
static_assert((BLOCK_MAX_TEXELS % ASTCENC_SIMD_WIDTH) == 0,
|
|
"BLOCK_MAX_TEXELS must be multiple of ASTCENC_SIMD_WIDTH");
|
|
|
|
static_assert((BLOCK_MAX_WEIGHTS % ASTCENC_SIMD_WIDTH) == 0,
|
|
"BLOCK_MAX_WEIGHTS must be multiple of ASTCENC_SIMD_WIDTH");
|
|
|
|
static_assert((WEIGHTS_MAX_BLOCK_MODES % ASTCENC_SIMD_WIDTH) == 0,
|
|
"WEIGHTS_MAX_BLOCK_MODES must be multiple of ASTCENC_SIMD_WIDTH");
|
|
|
|
|
|
/* ============================================================================
|
|
Parallel execution control
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief A simple counter-based manager for parallel task execution.
|
|
*
|
|
* The task processing execution consists of:
|
|
*
|
|
* * A single-threaded init stage.
|
|
* * A multi-threaded processing stage.
|
|
* * A condition variable so threads can wait for processing completion.
|
|
*
|
|
* The init stage will be executed by the first thread to arrive in the critical section, there is
|
|
* no main thread in the thread pool.
|
|
*
|
|
* The processing stage uses dynamic dispatch to assign task tickets to threads on an on-demand
|
|
* basis. Threads may each therefore executed different numbers of tasks, depending on their
|
|
* processing complexity. The task queue and the task tickets are just counters; the caller must map
|
|
* these integers to an actual processing partition in a specific problem domain.
|
|
*
|
|
* The exit wait condition is needed to ensure processing has finished before a worker thread can
|
|
* progress to the next stage of the pipeline. Specifically a worker may exit the processing stage
|
|
* because there are no new tasks to assign to it while other worker threads are still processing.
|
|
* Calling @c wait() will ensure that all other worker have finished before the thread can proceed.
|
|
*
|
|
* The basic usage model:
|
|
*
|
|
* // --------- From single-threaded code ---------
|
|
*
|
|
* // Reset the tracker state
|
|
* manager->reset()
|
|
*
|
|
* // --------- From multi-threaded code ---------
|
|
*
|
|
* // Run the stage init; only first thread actually runs the lambda
|
|
* manager->init(<lambda>)
|
|
*
|
|
* do
|
|
* {
|
|
* // Request a task assignment
|
|
* uint task_count;
|
|
* uint base_index = manager->get_tasks(<granule>, task_count);
|
|
*
|
|
* // Process any tasks we were given (task_count <= granule size)
|
|
* if (task_count)
|
|
* {
|
|
* // Run the user task processing code for N tasks here
|
|
* ...
|
|
*
|
|
* // Flag these tasks as complete
|
|
* manager->complete_tasks(task_count);
|
|
* }
|
|
* } while (task_count);
|
|
*
|
|
* // Wait for all threads to complete tasks before progressing
|
|
* manager->wait()
|
|
*
|
|
* // Run the stage term; only first thread actually runs the lambda
|
|
* manager->term(<lambda>)
|
|
*/
|
|
class ParallelManager
|
|
{
|
|
private:
|
|
/** @brief Lock used for critical section and condition synchronization. */
|
|
std::mutex m_lock;
|
|
|
|
/** @brief True if the stage init() step has been executed. */
|
|
bool m_init_done;
|
|
|
|
/** @brief True if the stage term() step has been executed. */
|
|
bool m_term_done;
|
|
|
|
/** @brief Contition variable for tracking stage processing completion. */
|
|
std::condition_variable m_complete;
|
|
|
|
/** @brief Number of tasks started, but not necessarily finished. */
|
|
std::atomic<unsigned int> m_start_count;
|
|
|
|
/** @brief Number of tasks finished. */
|
|
unsigned int m_done_count;
|
|
|
|
/** @brief Number of tasks that need to be processed. */
|
|
unsigned int m_task_count;
|
|
|
|
public:
|
|
/** @brief Create a new ParallelManager. */
|
|
ParallelManager()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
/**
|
|
* @brief Reset the tracker for a new processing batch.
|
|
*
|
|
* This must be called from single-threaded code before starting the multi-threaded procesing
|
|
* operations.
|
|
*/
|
|
void reset()
|
|
{
|
|
m_init_done = false;
|
|
m_term_done = false;
|
|
m_start_count = 0;
|
|
m_done_count = 0;
|
|
m_task_count = 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Trigger the pipeline stage init step.
|
|
*
|
|
* This can be called from multi-threaded code. The first thread to hit this will process the
|
|
* initialization. Other threads will block and wait for it to complete.
|
|
*
|
|
* @param init_func Callable which executes the stage initialization. It must return the
|
|
* total number of tasks in the stage.
|
|
*/
|
|
void init(std::function<unsigned int(void)> init_func)
|
|
{
|
|
std::lock_guard<std::mutex> lck(m_lock);
|
|
if (!m_init_done)
|
|
{
|
|
m_task_count = init_func();
|
|
m_init_done = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Trigger the pipeline stage init step.
|
|
*
|
|
* This can be called from multi-threaded code. The first thread to hit this will process the
|
|
* initialization. Other threads will block and wait for it to complete.
|
|
*
|
|
* @param task_count Total number of tasks needing processing.
|
|
*/
|
|
void init(unsigned int task_count)
|
|
{
|
|
std::lock_guard<std::mutex> lck(m_lock);
|
|
if (!m_init_done)
|
|
{
|
|
m_task_count = task_count;
|
|
m_init_done = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Request a task assignment.
|
|
*
|
|
* Assign up to @c granule tasks to the caller for processing.
|
|
*
|
|
* @param granule Maximum number of tasks that can be assigned.
|
|
* @param[out] count Actual number of tasks assigned, or zero if no tasks were assigned.
|
|
*
|
|
* @return Task index of the first assigned task; assigned tasks increment from this.
|
|
*/
|
|
unsigned int get_task_assignment(unsigned int granule, unsigned int& count)
|
|
{
|
|
unsigned int base = m_start_count.fetch_add(granule, std::memory_order_relaxed);
|
|
if (base >= m_task_count)
|
|
{
|
|
count = 0;
|
|
return 0;
|
|
}
|
|
|
|
count = astc::min(m_task_count - base, granule);
|
|
return base;
|
|
}
|
|
|
|
/**
|
|
* @brief Complete a task assignment.
|
|
*
|
|
* Mark @c count tasks as complete. This will notify all threads blocked on @c wait() if this
|
|
* completes the processing of the stage.
|
|
*
|
|
* @param count The number of completed tasks.
|
|
*/
|
|
void complete_task_assignment(unsigned int count)
|
|
{
|
|
// Note: m_done_count cannot use an atomic without the mutex; this has a race between the
|
|
// update here and the wait() for other threads
|
|
std::unique_lock<std::mutex> lck(m_lock);
|
|
this->m_done_count += count;
|
|
if (m_done_count == m_task_count)
|
|
{
|
|
lck.unlock();
|
|
m_complete.notify_all();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Wait for stage processing to complete.
|
|
*/
|
|
void wait()
|
|
{
|
|
std::unique_lock<std::mutex> lck(m_lock);
|
|
m_complete.wait(lck, [this]{ return m_done_count == m_task_count; });
|
|
}
|
|
|
|
/**
|
|
* @brief Trigger the pipeline stage term step.
|
|
*
|
|
* This can be called from multi-threaded code. The first thread to hit this will process the
|
|
* thread termintion. Caller must have called @c wait() prior to calling this function to ensure
|
|
* that processing is complete.
|
|
*
|
|
* @param term_func Callable which executes the stage termination.
|
|
*/
|
|
void term(std::function<void(void)> term_func)
|
|
{
|
|
std::lock_guard<std::mutex> lck(m_lock);
|
|
if (!m_term_done)
|
|
{
|
|
term_func();
|
|
m_term_done = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
/* ============================================================================
|
|
Commonly used data structures
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief The ASTC endpoint formats.
|
|
*
|
|
* Note, the values here are used directly in the encoding in the format so do not rearrange.
|
|
*/
|
|
enum endpoint_formats
|
|
{
|
|
FMT_LUMINANCE = 0,
|
|
FMT_LUMINANCE_DELTA = 1,
|
|
FMT_HDR_LUMINANCE_LARGE_RANGE = 2,
|
|
FMT_HDR_LUMINANCE_SMALL_RANGE = 3,
|
|
FMT_LUMINANCE_ALPHA = 4,
|
|
FMT_LUMINANCE_ALPHA_DELTA = 5,
|
|
FMT_RGB_SCALE = 6,
|
|
FMT_HDR_RGB_SCALE = 7,
|
|
FMT_RGB = 8,
|
|
FMT_RGB_DELTA = 9,
|
|
FMT_RGB_SCALE_ALPHA = 10,
|
|
FMT_HDR_RGB = 11,
|
|
FMT_RGBA = 12,
|
|
FMT_RGBA_DELTA = 13,
|
|
FMT_HDR_RGB_LDR_ALPHA = 14,
|
|
FMT_HDR_RGBA = 15
|
|
};
|
|
|
|
/**
|
|
* @brief The ASTC quantization methods.
|
|
*
|
|
* Note, the values here are used directly in the encoding in the format so do not rearrange.
|
|
*/
|
|
enum quant_method
|
|
{
|
|
QUANT_2 = 0,
|
|
QUANT_3 = 1,
|
|
QUANT_4 = 2,
|
|
QUANT_5 = 3,
|
|
QUANT_6 = 4,
|
|
QUANT_8 = 5,
|
|
QUANT_10 = 6,
|
|
QUANT_12 = 7,
|
|
QUANT_16 = 8,
|
|
QUANT_20 = 9,
|
|
QUANT_24 = 10,
|
|
QUANT_32 = 11,
|
|
QUANT_40 = 12,
|
|
QUANT_48 = 13,
|
|
QUANT_64 = 14,
|
|
QUANT_80 = 15,
|
|
QUANT_96 = 16,
|
|
QUANT_128 = 17,
|
|
QUANT_160 = 18,
|
|
QUANT_192 = 19,
|
|
QUANT_256 = 20
|
|
};
|
|
|
|
/**
|
|
* @brief The number of levels use by an ASTC quantization method.
|
|
*
|
|
* @param method The quantization method
|
|
*
|
|
* @return The number of levels used by @c method.
|
|
*/
|
|
static inline unsigned int get_quant_level(quant_method method)
|
|
{
|
|
switch(method)
|
|
{
|
|
case QUANT_2: return 2;
|
|
case QUANT_3: return 3;
|
|
case QUANT_4: return 4;
|
|
case QUANT_5: return 5;
|
|
case QUANT_6: return 6;
|
|
case QUANT_8: return 8;
|
|
case QUANT_10: return 10;
|
|
case QUANT_12: return 12;
|
|
case QUANT_16: return 16;
|
|
case QUANT_20: return 20;
|
|
case QUANT_24: return 24;
|
|
case QUANT_32: return 32;
|
|
case QUANT_40: return 40;
|
|
case QUANT_48: return 48;
|
|
case QUANT_64: return 64;
|
|
case QUANT_80: return 80;
|
|
case QUANT_96: return 96;
|
|
case QUANT_128: return 128;
|
|
case QUANT_160: return 160;
|
|
case QUANT_192: return 192;
|
|
case QUANT_256: return 256;
|
|
// Unreachable - the enum is fully described
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Computed metrics about a partition in a block.
|
|
*/
|
|
struct partition_metrics
|
|
{
|
|
/** @brief The square of the color range (max - min) spanned by texels in this partition. */
|
|
vfloat4 range_sq;
|
|
|
|
/** @brief The sum of the error weights for texels in this partition. */
|
|
vfloat4 error_weight;
|
|
|
|
/** @brief The color scale factor used to weight color channels. */
|
|
vfloat4 color_scale;
|
|
|
|
/** @brief The 1 / color_scale used to avoid divisions. */
|
|
vfloat4 icolor_scale;
|
|
|
|
/** @brief The error-weighted average color in the partition. */
|
|
vfloat4 avg;
|
|
|
|
/** @brief The dominant error-weighted direction in the partition. */
|
|
vfloat4 dir;
|
|
};
|
|
|
|
/**
|
|
* @brief Computed lines for a a three component analysis.
|
|
*/
|
|
struct partition_lines3
|
|
{
|
|
/** @brief Line for uncorrelated chroma. */
|
|
line3 uncor_line;
|
|
|
|
/** @brief Line for correlated chroma, passing though the origin. */
|
|
line3 samec_line;
|
|
|
|
/** @brief Postprocessed line for uncorrelated chroma. */
|
|
processed_line3 uncor_pline;
|
|
|
|
/** @brief Postprocessed line for correlated chroma, passing though the origin. */
|
|
processed_line3 samec_pline;
|
|
|
|
/** @brief The length of the line for uncorrelated chroma. */
|
|
float uncor_line_len;
|
|
|
|
/** @brief The length of the line for correlated chroma. */
|
|
float samec_line_len;
|
|
};
|
|
|
|
/**
|
|
* @brief The partition information for a single partition.
|
|
*
|
|
* ASTC has a total of 1024 candidate partitions for each of 2/3/4 partition counts, although this
|
|
* 1024 includes seeds that generate duplicates of other seeds and seeds that generate completely
|
|
* empty partitions. These are both valid encodings, but astcenc will skip both during compression
|
|
* as they are not useful.
|
|
*/
|
|
struct partition_info
|
|
{
|
|
/** @brief The number of partitions in this partitioning. */
|
|
unsigned int partition_count;
|
|
|
|
/**
|
|
* @brief The number of texels in each partition.
|
|
*
|
|
* Note that some seeds result in zero texels assigned to a partition are valid, but are skipped
|
|
* by this compressor as there is no point spending bits encoding an unused color endpoint.
|
|
*/
|
|
uint8_t partition_texel_count[BLOCK_MAX_PARTITIONS];
|
|
|
|
/** @brief The partition of each texel in the block. */
|
|
uint8_t partition_of_texel[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The list of texels in each partition. */
|
|
uint8_t texels_of_partition[BLOCK_MAX_PARTITIONS][BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The canonical partition coverage pattern used during block partition search. */
|
|
uint64_t coverage_bitmaps[BLOCK_MAX_PARTITIONS];
|
|
};
|
|
|
|
/**
|
|
* @brief The weight grid information for a single decimation pattern.
|
|
*
|
|
* ASTC can store one weight per texel, but is also capable of storing lower resoution weight grids
|
|
* that are interpolated during decompression to assign a with to a texel. Storing fewer weights
|
|
* can free up a substantial amount of bits that we can then spend on more useful things, such as
|
|
* more accurate endpoints and weights, or additional partitions.
|
|
*
|
|
* This data structure is used to store information about a single weight grid decimation pattern,
|
|
* for a single block size.
|
|
*/
|
|
struct decimation_info
|
|
{
|
|
/** @brief The total number of texels in the block. */
|
|
uint8_t texel_count;
|
|
|
|
/** @brief The total number of weights stored. */
|
|
uint8_t weight_count;
|
|
|
|
/** @brief The number of stored weights in the X dimension. */
|
|
uint8_t weight_x;
|
|
|
|
/** @brief The number of stored weights in the Y dimension. */
|
|
uint8_t weight_y;
|
|
|
|
/** @brief The number of stored weights in the Z dimension. */
|
|
uint8_t weight_z;
|
|
|
|
/** @brief The number of stored weights that contribute to each texel, between 1 and 4. */
|
|
uint8_t texel_weight_count[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The weight index of the N weights that need to be interpolated for each texel. */
|
|
uint8_t texel_weights_4t[4][BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The bilinear interpolation weighting of the N input weights for each texel, between 0 and 16. */
|
|
uint8_t texel_weights_int_4t[4][BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The bilinear interpolation weighting of the N input weights for each texel, between 0 and 1. */
|
|
alignas(ASTCENC_VECALIGN) float texel_weights_float_4t[4][BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The number of texels that each stored weight contributes to. */
|
|
uint8_t weight_texel_count[BLOCK_MAX_WEIGHTS];
|
|
|
|
/** @brief The list of weights that contribute to each texel. */
|
|
uint8_t weight_texel[BLOCK_MAX_TEXELS][BLOCK_MAX_WEIGHTS];
|
|
|
|
/** @brief The list of weight indices that contribute to each texel. */
|
|
alignas(ASTCENC_VECALIGN) float weights_flt[BLOCK_MAX_TEXELS][BLOCK_MAX_WEIGHTS];
|
|
|
|
/**
|
|
* @brief Folded structure for faster access:
|
|
* texel_weights_texel[i][j][.] = texel_weights[.][weight_texel[i][j]]
|
|
*/
|
|
uint8_t texel_weights_texel[BLOCK_MAX_WEIGHTS][BLOCK_MAX_TEXELS][4];
|
|
|
|
/**
|
|
* @brief Folded structure for faster access:
|
|
* texel_weights_float_texel[i][j][.] = texel_weights_float[.][weight_texel[i][j]]
|
|
*/
|
|
float texel_weights_float_texel[BLOCK_MAX_WEIGHTS][BLOCK_MAX_TEXELS][4];
|
|
};
|
|
|
|
/**
|
|
* @brief Metadata for single block mode for a specific block size.
|
|
*/
|
|
struct block_mode
|
|
{
|
|
/** @brief The block mode index in the ASTC encoded form. */
|
|
uint16_t mode_index;
|
|
|
|
/** @brief The decimation mode index in the compressor reindexed list. */
|
|
uint8_t decimation_mode;
|
|
|
|
/** @brief The weight quantization used by this block mode. */
|
|
uint8_t quant_mode;
|
|
|
|
/** @brief Is a dual weight plane used by this block mode? */
|
|
uint8_t is_dual_plane : 1;
|
|
|
|
/** @brief Is this mode enabled in the current search preset? */
|
|
uint8_t percentile_hit : 1;
|
|
|
|
/** @brief Is this mode enabled for early fast-path searches in the current search preset? */
|
|
uint8_t percentile_always : 1;
|
|
|
|
/**
|
|
* @brief Get the weight quantization used by this block mode.
|
|
*
|
|
* @return The quantization level.
|
|
*/
|
|
inline quant_method get_weight_quant_mode() const
|
|
{
|
|
return (quant_method)this->quant_mode;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Metadata for single decimation mode for a specific block size.
|
|
*/
|
|
struct decimation_mode
|
|
{
|
|
/** @brief The max weight precision for 1 plane, or -1 if not supported. */
|
|
int8_t maxprec_1plane;
|
|
|
|
/** @brief The max weight precision for 2 planes, or -1 if not supported. */
|
|
int8_t maxprec_2planes;
|
|
|
|
/** @brief Is this mode enabled in the current search preset? */
|
|
uint8_t percentile_hit : 1;
|
|
|
|
/** @brief Is this mode enabled for early fast-path searches in the current search preset? */
|
|
uint8_t percentile_always : 1;
|
|
};
|
|
|
|
/**
|
|
* @brief Data tables for a single block size.
|
|
*
|
|
* The decimation tables store the information to apply weight grid dimension reductions. We only
|
|
* store the decimation modes that are actually needed by the current context; many of the possible
|
|
* modes will be unused (too many weights for the current block size or disabled by heuristics). The
|
|
* actual number of weights stored is @c decimation_mode_count, and the @c decimation_modes and
|
|
* @c decimation_tables arrays store the active modes contiguously at the start of the array. These
|
|
* entries are not stored in any particuar order.
|
|
*
|
|
* The block mode tables store the unpacked block mode settings. Block modes are stored in the
|
|
* compressed block as an 11 bit field, but for any given block size and set of compressor
|
|
* heuristics, only a subset of the block modes will be used. The actual number of block modes
|
|
* stored is indicated in @c block_mode_count, and the @c block_modes array store the active modes
|
|
* contiguously at the start of the array. These entries are stored in incrementing "packed" value
|
|
* order, which doesn't mean much once unpacked. To allow decompressors to reference the packed data
|
|
* efficiently the @c block_mode_packed_index array stores the mapping between physical ID and the
|
|
* actual remapped array index.
|
|
*/
|
|
struct block_size_descriptor
|
|
{
|
|
/** @brief The block X dimension, in texels. */
|
|
uint8_t xdim;
|
|
|
|
/** @brief The block Y dimension, in texels. */
|
|
uint8_t ydim;
|
|
|
|
/** @brief The block Z dimension, in texels. */
|
|
uint8_t zdim;
|
|
|
|
/** @brief The block total texel count. */
|
|
uint8_t texel_count;
|
|
|
|
/** @brief The number of stored decimation modes. */
|
|
unsigned int decimation_mode_count;
|
|
|
|
/** @brief The number of stored block modes. */
|
|
unsigned int block_mode_count;
|
|
|
|
/** @brief The active decimation modes, stored in low indices. */
|
|
decimation_mode decimation_modes[WEIGHTS_MAX_DECIMATION_MODES];
|
|
|
|
/** @brief The active decimation tables, stored in low indices. */
|
|
const decimation_info *decimation_tables[WEIGHTS_MAX_DECIMATION_MODES];
|
|
|
|
/** @brief The packed block mode array index, or @c BLOCK_BAD_BLOCK_MODE if not active. */
|
|
uint16_t block_mode_packed_index[WEIGHTS_MAX_BLOCK_MODES];
|
|
|
|
/** @brief The active block modes, stored in low indices. */
|
|
block_mode block_modes[WEIGHTS_MAX_BLOCK_MODES];
|
|
|
|
/** @brief The partion tables for all of the possible partitions. */
|
|
partition_info partitions[(3 * BLOCK_MAX_PARTITIONINGS) + 1];
|
|
|
|
/** @brief The active texels for k-means partition selection. */
|
|
uint8_t kmeans_texels[BLOCK_MAX_KMEANS_TEXELS];
|
|
|
|
/**
|
|
* @brief Get the block mode structure for index @c block_mode.
|
|
*
|
|
* This function can only return block modes that are enabled by the current compressor config.
|
|
* Decompression from an arbitrary source should not use this without first checking that the
|
|
* packed block mode index is not @c BLOCK_BAD_BLOCK_MODE.
|
|
*
|
|
* @param block_mode The packed block mode index.
|
|
*
|
|
* @return The block mode structure.
|
|
*/
|
|
const block_mode& get_block_mode(unsigned int block_mode) const
|
|
{
|
|
unsigned int packed_index = this->block_mode_packed_index[block_mode];
|
|
assert(packed_index != BLOCK_BAD_BLOCK_MODE && packed_index < this->block_mode_count);
|
|
return block_modes[packed_index];
|
|
}
|
|
|
|
/**
|
|
* @brief Get the decimation mode structure for index @c decimation_mode.
|
|
*
|
|
* This function can only return decimation modes that are enabled by the current compressor
|
|
* config. The mode array is stored packed, but this is only ever indexed by the packed index
|
|
* stored in the @c block_mode and never exists in an unpacked form.
|
|
*
|
|
* @param decimation_mode The packed decimation mode index.
|
|
*
|
|
* @return The decimation mode structure.
|
|
*/
|
|
const decimation_mode& get_decimation_mode(unsigned int decimation_mode) const
|
|
{
|
|
return this->decimation_modes[decimation_mode];
|
|
}
|
|
|
|
/**
|
|
* @brief Get the decimation info structure for index @c decimation_mode.
|
|
*
|
|
* This function can only return decimation modes that are enabled by the current compressor
|
|
* config. The mode array is stored packed, but this is only ever indexed by the packed index
|
|
* stored in the @c block_mode and never exists in an unpacked form.
|
|
*
|
|
* @param decimation_mode The packed decimation mode index.
|
|
*
|
|
* @return The decimation info structure.
|
|
*/
|
|
const decimation_info& get_decimation_info(unsigned int decimation_mode) const
|
|
{
|
|
return *this->decimation_tables[decimation_mode];
|
|
}
|
|
|
|
/**
|
|
* @brief Get the partition info table for a given partition count.
|
|
*
|
|
* @param partition_count The number of partitions we want the table for.
|
|
*
|
|
* @return The pointer to the table of 1024 entries (for 2/3/4 parts) or 1 entry (for 1 part).
|
|
*/
|
|
const partition_info* get_partition_table(unsigned int partition_count) const
|
|
{
|
|
if (partition_count == 1)
|
|
{
|
|
partition_count = 5;
|
|
}
|
|
unsigned int index = (partition_count - 2) * BLOCK_MAX_PARTITIONINGS;
|
|
return this->partitions + index;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the partition info structure for a given partition count and seed.
|
|
*
|
|
* @param partition_count The number of partitions we want the info for.
|
|
* @param index The partition seed (between 0 and 1023).
|
|
*
|
|
* @return The partition info structure.
|
|
*/
|
|
const partition_info& get_partition_info(unsigned int partition_count, unsigned int index) const
|
|
{
|
|
return get_partition_table(partition_count)[index];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The image data for a single block.
|
|
*
|
|
* The @c data_[rgba] fields store the image data in an encoded SoA float form designed for easy
|
|
* vectorization. Input data is converted to float and stored as values between 0 and 65535. LDR
|
|
* data is stored as direct UNORM data, HDR data is stored as LNS data.
|
|
*
|
|
* The @c rgb_lns and @c alpha_lns fields that assigned a per-texel use of HDR are only used during
|
|
* decompression. The current compressor will always use HDR endpoint formats when in HDR mode.
|
|
*/
|
|
struct image_block
|
|
{
|
|
/** @brief The input (compress) or output (decompress) data for the red color component. */
|
|
float data_r[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The input (compress) or output (decompress) data for the green color component. */
|
|
float data_g[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The input (compress) or output (decompress) data for the blue color component. */
|
|
float data_b[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The input (compress) or output (decompress) data for the alpha color component. */
|
|
float data_a[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The original data for texel 0 for constant color block encoding. */
|
|
vfloat4 origin_texel;
|
|
|
|
/** @brief The min component value of all texels in the block. */
|
|
vfloat4 data_min;
|
|
|
|
/** @brief The max component value of all texels in the block. */
|
|
vfloat4 data_max;
|
|
|
|
/** @brief Is this greyscale block where R == G == B for all texels? */
|
|
bool grayscale;
|
|
|
|
/** @brief Set to 1 if a texel is using HDR RGB endpoints (decompression only). */
|
|
uint8_t rgb_lns[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief Set to 1 if a texel is using HDR alpha endpoints (decompression only). */
|
|
uint8_t alpha_lns[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The X position of this block in the input or output image. */
|
|
unsigned int xpos;
|
|
|
|
/** @brief The Y position of this block in the input or output image. */
|
|
unsigned int ypos;
|
|
|
|
/** @brief The Z position of this block in the input or output image. */
|
|
unsigned int zpos;
|
|
|
|
/**
|
|
* @brief Get an RGBA texel value from the data.
|
|
*
|
|
* @param index The texel index.
|
|
*
|
|
* @return The texel in RGBA component ordering.
|
|
*/
|
|
inline vfloat4 texel(unsigned int index) const
|
|
{
|
|
return vfloat4(data_r[index],
|
|
data_g[index],
|
|
data_b[index],
|
|
data_a[index]);
|
|
}
|
|
|
|
/**
|
|
* @brief Get an RGB texel value from the data.
|
|
*
|
|
* @param index The texel index.
|
|
*
|
|
* @return The texel in RGB0 component ordering.
|
|
*/
|
|
inline vfloat4 texel3(unsigned int index) const
|
|
{
|
|
return vfloat3(data_r[index],
|
|
data_g[index],
|
|
data_b[index]);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the default alpha value for endpoints that don't store it.
|
|
*
|
|
* The default depends on whether the alpha endpoint is LDR or HDR.
|
|
*
|
|
* @return The alpha value in the scaled range used by the compressor.
|
|
*/
|
|
inline float get_default_alpha() const
|
|
{
|
|
return this->alpha_lns[0] ? (float)0x7800 : (float)0xFFFF;
|
|
}
|
|
|
|
/**
|
|
* @brief Test if this block is using alpha.
|
|
*
|
|
* TODO: This looks suspect, but matches the original astcenc 1.7 code. This checks that the
|
|
* alpha is not constant (no weight needed), NOT that it is 1.0 and not stored as an endpoint.
|
|
* Review all uses of this function and check that it is sensible ...
|
|
*
|
|
* @return @c true if the alpha value is not constant across the block, @c false otherwise.
|
|
*/
|
|
inline bool is_using_alpha() const
|
|
{
|
|
return this->data_min.lane<3>() != this->data_max.lane<3>();
|
|
}
|
|
|
|
/**
|
|
* @brief Test if this block is a luminance block with constant 1.0 alpha.
|
|
*
|
|
* @return @c true if the block is a luminance block , @c false otherwise.
|
|
*/
|
|
inline bool is_luminance() const
|
|
{
|
|
float default_alpha = this->get_default_alpha();
|
|
bool alpha1 = (this->data_min.lane<3>() == default_alpha) &&
|
|
(this->data_max.lane<3>() == default_alpha);
|
|
return this->grayscale && alpha1;
|
|
}
|
|
|
|
/**
|
|
* @brief Test if this block is a luminance block with variable alpha.
|
|
*
|
|
* @return @c true if the block is a luminance + alpha block , @c false otherwise.
|
|
*/
|
|
inline bool is_luminancealpha() const
|
|
{
|
|
float default_alpha = this->get_default_alpha();
|
|
bool alpha1 = (this->data_min.lane<3>() == default_alpha) &&
|
|
(this->data_max.lane<3>() == default_alpha);
|
|
return this->grayscale && !alpha1;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Data structure representing per-texel and per-component error weights for a block.
|
|
*
|
|
* This structure stores a multiplier for the error weight to apply to each component when computing
|
|
* block errors. This can be used as a general purpose technique to to amplify or diminish the
|
|
* significance of texels and individual color components, based on what is being stored and the
|
|
* compressor heuristics. It can be applied in many different ways, some of which are outlined in
|
|
* the description below (this is not exhaustive).
|
|
*
|
|
* For blocks that span the edge of the texture, the weighting for texels outside of the texture
|
|
* bounds can zeroed to maximize the quality of the texels inside the texture.
|
|
*
|
|
* For textures storing fewer than 4 components the weighting for color components that are unused
|
|
* can be zeroed to maximize the quality of the components that are used. This is particularly
|
|
* important for two component textures, which must be imported in LLLA format to match the two
|
|
* component endpoint encoding. Without manual component weighting to correct significance the "L"
|
|
* would be treated as three times more important than A because of the replication.
|
|
*
|
|
* For HDR textures we can use perceptual weighting which os approximately inverse to the luminance
|
|
* of a texel.
|
|
*
|
|
* For normal maps we can use perceptual weighting which assigns higher weight to low-variability
|
|
* regions than to high-variability regions, ensuring smooth surfaces don't pick up artifacts.
|
|
*
|
|
* For transparent texels we can multiply the RGB weights by the alpha value, ensuring that
|
|
* the least transprent texels maintain the highest accuracy.
|
|
*/
|
|
struct error_weight_block
|
|
{
|
|
/** @brief The full per texel per component error weights. */
|
|
vfloat4 error_weights[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The full per texel per component error weights. */
|
|
float texel_weight[BLOCK_MAX_TEXELS];
|
|
|
|
|
|
/** @brief The average of the GBA error weights per texel. */
|
|
float texel_weight_gba[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The average of the RBA error weights per texel. */
|
|
float texel_weight_rba[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The average of the RGA error weights per texel. */
|
|
float texel_weight_rga[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The average of the RGB error weights per texel. */
|
|
float texel_weight_rgb[BLOCK_MAX_TEXELS];
|
|
|
|
|
|
/** @brief The average of the RG error weights per texel. */
|
|
float texel_weight_rg[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The average of the RB error weights per texel. */
|
|
float texel_weight_rb[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The average of the GB error weights per texel. */
|
|
float texel_weight_gb[BLOCK_MAX_TEXELS];
|
|
|
|
|
|
/** @brief The individual R component error weights per texel. */
|
|
float texel_weight_r[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The individual G component error weights per texel. */
|
|
float texel_weight_g[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The individual B component error weights per texel. */
|
|
float texel_weight_b[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The individual A component error weights per texel. */
|
|
float texel_weight_a[BLOCK_MAX_TEXELS];
|
|
};
|
|
|
|
/**
|
|
* @brief Data structure storing the color endpoints for a block.
|
|
*/
|
|
struct endpoints
|
|
{
|
|
/** @brief The number of partition endpoints stored. */
|
|
unsigned int partition_count;
|
|
|
|
/** @brief The colors for endpoint 0. */
|
|
vfloat4 endpt0[BLOCK_MAX_PARTITIONS];
|
|
|
|
/** @brief The colors for endpoint 1. */
|
|
vfloat4 endpt1[BLOCK_MAX_PARTITIONS];
|
|
};
|
|
|
|
/**
|
|
* @brief Data structure storing the color endpoints and weights.
|
|
*/
|
|
struct endpoints_and_weights
|
|
{
|
|
/** @brief True if all active values in weight_error_scale are the same. */
|
|
bool is_constant_weight_error_scale;
|
|
|
|
/** @brief The color endpoints. */
|
|
endpoints ep;
|
|
|
|
/** @brief The undecimated and unquantized weight for each texel. */
|
|
alignas(ASTCENC_VECALIGN) float weights[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The undecimated and unquantized weight error scaling for each texel. */
|
|
alignas(ASTCENC_VECALIGN) float weight_error_scale[BLOCK_MAX_TEXELS];
|
|
};
|
|
|
|
/**
|
|
* @brief Utility storing estimated errors from choosing particular endpoint encodings.
|
|
*/
|
|
struct encoding_choice_errors
|
|
{
|
|
/** @brief Error of using LDR RGB-scale instead of complete endpoints. */
|
|
float rgb_scale_error;
|
|
|
|
/** @brief Error of using HDR RGB-scale instead of complete endpoints. */
|
|
float rgb_luma_error;
|
|
|
|
/** @brief Error of using luminance instead of RGB. */
|
|
float luminance_error;
|
|
|
|
/** @brief Error of discarding alpha and using a constant 1.0 alpha. */
|
|
float alpha_drop_error;
|
|
|
|
/** @brief Can we use delta offset encoding? */
|
|
bool can_offset_encode;
|
|
|
|
/** @brief CAn we use blue contraction encoding? */
|
|
bool can_blue_contract;
|
|
};
|
|
|
|
/**
|
|
* @brief Preallocated working buffers, allocated per thread during context creation.
|
|
*/
|
|
struct alignas(ASTCENC_VECALIGN) compression_working_buffers
|
|
{
|
|
/** @brief Ideal endpoints and weights for plane 1. */
|
|
endpoints_and_weights ei1;
|
|
|
|
/** @brief Ideal endpoints and weights for plane 2. */
|
|
endpoints_and_weights ei2;
|
|
|
|
/** @brief Ideal endpoints and weights for plane 1. */
|
|
endpoints_and_weights eix1[WEIGHTS_MAX_DECIMATION_MODES];
|
|
|
|
/** @brief Ideal endpoints and weights for plane 2. */
|
|
endpoints_and_weights eix2[WEIGHTS_MAX_DECIMATION_MODES];
|
|
|
|
/** @brief The error weight block for the current thread. */
|
|
error_weight_block ewb;
|
|
|
|
/** @brief Decimated and weight values, rounded to quantization points but not stored packed. */
|
|
alignas(ASTCENC_VECALIGN) float decimated_quantized_weights[2 * WEIGHTS_MAX_DECIMATION_MODES * BLOCK_MAX_WEIGHTS];
|
|
|
|
/** @brief Decimated and unquantized weight values. */
|
|
alignas(ASTCENC_VECALIGN) float decimated_weights[2 * WEIGHTS_MAX_DECIMATION_MODES * BLOCK_MAX_WEIGHTS];
|
|
|
|
/** @brief Decimated and quantized weight values stored in the packed quantized weight range. */
|
|
alignas(ASTCENC_VECALIGN) float flt_quantized_decimated_quantized_weights[2 * WEIGHTS_MAX_BLOCK_MODES * BLOCK_MAX_WEIGHTS];
|
|
|
|
/** @brief Decimated and quantized weight values stored in the packed quantized weight range. */
|
|
alignas(ASTCENC_VECALIGN) uint8_t u8_quantized_decimated_quantized_weights[2 * WEIGHTS_MAX_BLOCK_MODES * BLOCK_MAX_WEIGHTS];
|
|
};
|
|
|
|
/**
|
|
* @brief Weight quantization transfer table.
|
|
*
|
|
* ASTC can store texel weights at many quantization levels, so for performance we store essential
|
|
* information about each level as a precomputed data structure. Unquantized weights are integers
|
|
* or floats in the range [0, 64].
|
|
*
|
|
* This structure provides a table, used to estimate the closest quantized weight for a given
|
|
* floating-point weight. For each quantized weight, the corresponding unquantized values. For each
|
|
* quantized weight, a previous-value and a next-value.
|
|
*/
|
|
struct quantization_and_transfer_table
|
|
{
|
|
/** @brief The quantization level used */
|
|
quant_method method;
|
|
|
|
/** @brief The unscrambled unquantized value. */
|
|
float unquantized_value_unsc[33];
|
|
|
|
/** @brief The scrambling order: value[map[i]] == value_unsc[i] */
|
|
int32_t scramble_map[32];
|
|
|
|
/** @brief The scrambled unquantized values. */
|
|
uint8_t unquantized_value[32];
|
|
|
|
/**
|
|
* @brief A table of previous-and-next weights, indexed by the current unquantized value.
|
|
* * bits 7:0 = previous-index, unquantized
|
|
* * bits 15:8 = next-index, unquantized
|
|
* * bits 23:16 = previous-index, quantized
|
|
* * bits 31:24 = next-index, quantized
|
|
*/
|
|
uint32_t prev_next_values[65];
|
|
};
|
|
|
|
|
|
/** @brief The precomputed quant and transfer table. */
|
|
extern const quantization_and_transfer_table quant_and_xfer_tables[12];
|
|
|
|
/** @brief The block is an error block, and will return error color or NaN. */
|
|
static constexpr uint8_t SYM_BTYPE_ERROR { 0 };
|
|
|
|
/** @brief The block is a constant color block using FP16 colors. */
|
|
static constexpr uint8_t SYM_BTYPE_CONST_F16 { 1 };
|
|
|
|
/** @brief The block is a constant color block using UNORM16 colors. */
|
|
static constexpr uint8_t SYM_BTYPE_CONST_U16 { 2 };
|
|
|
|
/** @brief The block is a normal non-constant color block. */
|
|
static constexpr uint8_t SYM_BTYPE_NONCONST { 3 };
|
|
|
|
/**
|
|
* @brief A symbolic representation of a compressed block.
|
|
*
|
|
* The symbolic representation stores the unpacked content of a single
|
|
* @c physical_compressed_block, in a form which is much easier to access for
|
|
* the rest of the compressor code.
|
|
*/
|
|
struct symbolic_compressed_block
|
|
{
|
|
/** @brief The block type, one of the @c SYM_BTYPE_* constants. */
|
|
uint8_t block_type;
|
|
|
|
/** @brief The number of partitions; valid for @c NONCONST blocks. */
|
|
uint8_t partition_count;
|
|
|
|
/** @brief Non-zero if the color formats matched; valid for @c NONCONST blocks. */
|
|
// TODO: Do we need to store this?
|
|
uint8_t color_formats_matched;
|
|
|
|
/** @brief The plane 2 color component, or -1 if single plane; valid for @c NONCONST blocks. */
|
|
// Try unsigned sentintel to avoid signext on load
|
|
int8_t plane2_component;
|
|
|
|
/** @brief The block mode; valid for @c NONCONST blocks. */
|
|
uint16_t block_mode;
|
|
|
|
/** @brief The partition index; valid for @c NONCONST blocks if 2 or more partitions. */
|
|
uint16_t partition_index;
|
|
|
|
/** @brief The endpoint color formats for each partition; valid for @c NONCONST blocks. */
|
|
uint8_t color_formats[BLOCK_MAX_PARTITIONS];
|
|
|
|
/** @brief The endpoint color formats for each partition; valid for @c NONCONST blocks. */
|
|
quant_method quant_mode;
|
|
|
|
/** @brief The error of the current encoding; valid for @c NONCONST blocks. */
|
|
float errorval;
|
|
|
|
// We can't have both of these at the same time
|
|
union {
|
|
/** @brief The constant color; valid for @c CONST blocks. */
|
|
int constant_color[BLOCK_MAX_COMPONENTS];
|
|
/** @brief The quantized endpoint color pairs; valid for @c NONCONST blocks. */
|
|
uint8_t color_values[BLOCK_MAX_PARTITIONS][8];
|
|
};
|
|
|
|
/** @brief The quantized and decimated weights.
|
|
*
|
|
* If dual plane, the second plane starts at @c weights[WEIGHTS_PLANE2_OFFSET].
|
|
*/
|
|
uint8_t weights[BLOCK_MAX_WEIGHTS];
|
|
|
|
/**
|
|
* @brief Get the weight quantization used by this block mode.
|
|
*
|
|
* @return The quantization level.
|
|
*/
|
|
inline quant_method get_color_quant_mode() const
|
|
{
|
|
return this->quant_mode;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief A physical representation of a compressed block.
|
|
*
|
|
* The physical representation stores the raw bytes of the format in memory.
|
|
*/
|
|
struct physical_compressed_block
|
|
{
|
|
/** @brief The ASTC encoded data for a single block. */
|
|
uint8_t data[16];
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief Parameter structure for @c compute_pixel_region_variance().
|
|
*
|
|
* This function takes a structure to avoid spilling arguments to the stack on every function
|
|
* invocation, as there are a lot of parameters.
|
|
*/
|
|
struct pixel_region_variance_args
|
|
{
|
|
/** @brief The image to analyze. */
|
|
const astcenc_image* img;
|
|
|
|
/** @brief The RGB component power adjustment. */
|
|
float rgb_power;
|
|
|
|
/** @brief The alpha component power adjustment. */
|
|
float alpha_power;
|
|
|
|
/** @brief The component swizzle pattern. */
|
|
astcenc_swizzle swz;
|
|
|
|
/** @brief Should the algorithm bother with Z axis processing? */
|
|
bool have_z;
|
|
|
|
/** @brief The kernel radius for average and variance. */
|
|
unsigned int avg_var_kernel_radius;
|
|
|
|
/** @brief The kernel radius for alpha processing. */
|
|
unsigned int alpha_kernel_radius;
|
|
|
|
/** @brief The X dimension of the working data to process. */
|
|
unsigned int size_x;
|
|
|
|
/** @brief The Y dimension of the working data to process. */
|
|
unsigned int size_y;
|
|
|
|
/** @brief The Z dimension of the working data to process. */
|
|
unsigned int size_z;
|
|
|
|
/** @brief The X position of first src and dst data in the data set. */
|
|
unsigned int offset_x;
|
|
|
|
/** @brief The Y position of first src and dst data in the data set. */
|
|
unsigned int offset_y;
|
|
|
|
/** @brief The Z position of first src and dst data in the data set. */
|
|
unsigned int offset_z;
|
|
|
|
/** @brief The working memory buffer. */
|
|
vfloat4 *work_memory;
|
|
};
|
|
|
|
/**
|
|
* @brief Parameter structure for @c compute_averages_and_variances_proc().
|
|
*/
|
|
struct avg_var_args
|
|
{
|
|
/** @brief The arguments for the nested variance computation. */
|
|
pixel_region_variance_args arg;
|
|
|
|
// The above has a reference to the image altread?
|
|
/** @brief The image X dimensions. */
|
|
unsigned int img_size_x;
|
|
|
|
/** @brief The image Y dimensions. */
|
|
unsigned int img_size_y;
|
|
|
|
/** @brief The image Z dimensions. */
|
|
unsigned int img_size_z;
|
|
|
|
/** @brief The maximum working block dimensions in X and Y dimensions. */
|
|
unsigned int blk_size_xy;
|
|
|
|
/** @brief The maximum working block dimensions in Z dimensions. */
|
|
unsigned int blk_size_z;
|
|
|
|
/** @brief The working block memory size. */
|
|
unsigned int work_memory_size;
|
|
};
|
|
|
|
#if defined(ASTCENC_DIAGNOSTICS)
|
|
class TraceLog; // See astcenc_diagnostic_trace for details.
|
|
#endif
|
|
|
|
/**
|
|
* @brief The astcenc compression context.
|
|
*/
|
|
struct astcenc_context
|
|
{
|
|
/** @brief The configuration this context was created with. */
|
|
astcenc_config config;
|
|
|
|
/** @brief The thread count supported by this context. */
|
|
unsigned int thread_count;
|
|
|
|
/** @brief The block size descriptor this context was created with. */
|
|
block_size_descriptor* bsd;
|
|
|
|
/*
|
|
* Fields below here are not needed in a decompress-only build, but some remain as they are
|
|
* small and it avoids littering the code with #ifdefs. The most significant contributors to
|
|
* large structure size are omitted.
|
|
*/
|
|
|
|
/** @brief The input images averages table, may be @c nullptr if not needed. */
|
|
vfloat4 *input_averages;
|
|
|
|
/** @brief The input image RGBA channel variances table, may be @c nullptr if not needed. */
|
|
vfloat4 *input_variances;
|
|
|
|
/** @brief The input image alpha channel variances table, may be @c nullptr if not needed. */
|
|
float *input_alpha_averages;
|
|
|
|
|
|
/** @brief The scratch workign buffers, one per thread (see @c thread_count). */
|
|
compression_working_buffers* working_buffers;
|
|
|
|
#if !defined(ASTCENC_DECOMPRESS_ONLY)
|
|
/** @brief The pixel region and variance worker arguments. */
|
|
avg_var_args avg_var_preprocess_args;
|
|
|
|
/** @brief The per-texel deblocking weights for the current block size. */
|
|
// TODO: Move to the BSD?
|
|
float deblock_weights[BLOCK_MAX_TEXELS];
|
|
|
|
/** @brief The parallel manager for averages and variances computation. */
|
|
ParallelManager manage_avg_var;
|
|
|
|
/** @brief The parallel manager for compression. */
|
|
ParallelManager manage_compress;
|
|
#endif
|
|
|
|
/** @brief The parallel manager for decompression. */
|
|
ParallelManager manage_decompress;
|
|
|
|
#if defined(ASTCENC_DIAGNOSTICS)
|
|
/**
|
|
* @brief The diagnostic trace logger.
|
|
*
|
|
* Note that this is a singleton, so can only be used in single threaded mode. It only exists
|
|
* here so we have a reference to close the file at the end of the capture.
|
|
*/
|
|
TraceLog* trace_log;
|
|
#endif
|
|
};
|
|
|
|
/* ============================================================================
|
|
Functionality for managing block sizes and partition tables.
|
|
============================================================================ */
|
|
|
|
// TODO: Make C++ constructor/destructor?
|
|
|
|
/**
|
|
* @brief Populate the block size descriptor for the target block size.
|
|
*
|
|
* This will also initialize the partition table metadata, which is stored as part of the BSD
|
|
* structure. All initialized block size descriptors must be terminated using a call to
|
|
* @c term_block_size_descriptor() to free resources.
|
|
*
|
|
* @param x_texels The number of texels in the block X dimension.
|
|
* @param y_texels The number of texels in the block Y dimension.
|
|
* @param z_texels The number of texels in the block Z dimension.
|
|
* @param can_omit_modes Can we discard modes that astcenc won't use, even if legal?
|
|
* @param mode_cutoff The block mode percentile cutoff [0-1].
|
|
* @param[out] bsd The descriptor to initialize.
|
|
*/
|
|
void init_block_size_descriptor(
|
|
unsigned int x_texels,
|
|
unsigned int y_texels,
|
|
unsigned int z_texels,
|
|
bool can_omit_modes,
|
|
float mode_cutoff,
|
|
block_size_descriptor& bsd);
|
|
|
|
/**
|
|
* @brief Terminate a block size descriptor and free associated resources.
|
|
*
|
|
* @param bsd The descriptor to terminate.
|
|
*/
|
|
void term_block_size_descriptor(
|
|
block_size_descriptor& bsd);
|
|
|
|
/**
|
|
* @brief Populate the partition tables for the target block size.
|
|
*
|
|
* Note the @c bsd descriptor must be initialized by calling @c init_block_size_descriptor() before
|
|
* calling this function.
|
|
*
|
|
* @param[out] bsd The block size information structure to populate.
|
|
*/
|
|
void init_partition_tables(
|
|
block_size_descriptor& bsd);
|
|
|
|
/**
|
|
* @brief Get the percentile table for 2D block modes.
|
|
*
|
|
* This is an empirically determined prioritization of which block modes to use in the search in
|
|
* terms of their centile (lower centiles = more useful).
|
|
*
|
|
* Returns a dynamically allocated array; caller must free with delete[].
|
|
*
|
|
* @param xdim The block x size.
|
|
* @param ydim The block y size.
|
|
*
|
|
* @return The unpacked table.
|
|
*/
|
|
const float *get_2d_percentile_table(
|
|
unsigned int xdim,
|
|
unsigned int ydim);
|
|
|
|
/**
|
|
* @brief Query if a 2D block size is legal.
|
|
*
|
|
* @return True if legal, false otherwise.
|
|
*/
|
|
bool is_legal_2d_block_size(
|
|
unsigned int xdim,
|
|
unsigned int ydim);
|
|
|
|
/**
|
|
* @brief Query if a 3D block size is legal.
|
|
*
|
|
* @return True if legal, false otherwise.
|
|
*/
|
|
bool is_legal_3d_block_size(
|
|
unsigned int xdim,
|
|
unsigned int ydim,
|
|
unsigned int zdim);
|
|
|
|
/* ============================================================================
|
|
Functionality for managing BISE quantization and unquantization.
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief The precomputed table for quantizing color values.
|
|
*
|
|
* Indexed by [quant_mode][data_value].
|
|
*/
|
|
extern const uint8_t color_quant_tables[21][256];
|
|
|
|
/**
|
|
* @brief The precomputed table for unquantizing color values.
|
|
*
|
|
* Indexed by [quant_mode][data_value].
|
|
*/
|
|
extern const uint8_t color_unquant_tables[21][256];
|
|
|
|
/**
|
|
* @brief The precomputed quant mode storage table.
|
|
*
|
|
* Indexing by [integercount/2][bits] gives us the quantization level for a given integer count and
|
|
* number of compressed storage bits. Returns -1 for cases where the requested integer count cannot
|
|
* ever fit in the supplied storage size.
|
|
*/
|
|
extern int8_t quant_mode_table[17][128];
|
|
|
|
/**
|
|
* @brief Initialize the quant mode table.
|
|
*
|
|
* This is stored in global memory so this only needs to be done once, but is typically done
|
|
* whenever a new context is created.
|
|
*/
|
|
void init_quant_mode_table();
|
|
|
|
/**
|
|
* @brief Encode a packed string using BISE.
|
|
*
|
|
* Note that BISE can return strings that are not a whole number of bytes in length, and ASTC can
|
|
* start storing strings in a block at arbitrary bit offsets in the encoded data.
|
|
*
|
|
* @param quant_level The BISE alphabet size.
|
|
* @param character_count The number of characters in the string.
|
|
* @param input_data The unpacked string, one byte per character.
|
|
* @param[in,out] output_data The output packed string.
|
|
* @param bit_offset The starting offset in the output storage.
|
|
*/
|
|
void encode_ise(
|
|
quant_method quant_level,
|
|
unsigned int character_count,
|
|
const uint8_t* input_data,
|
|
uint8_t* output_data,
|
|
unsigned int bit_offset);
|
|
|
|
/**
|
|
* @brief Decode a packed string using BISE.
|
|
*
|
|
* Note that BISE input strings are not a whole number of bytes in length, and ASTC can start
|
|
* strings at arbitrary bit offsets in the encoded data.
|
|
*
|
|
* @param quant_level The BISE alphabet size.
|
|
* @param character_count The number of characters in the string.
|
|
* @param input_data The packed string.
|
|
* @param[in,out] output_data The output storage, one byte per character.
|
|
* @param bit_offset The starting offset in the output storage.
|
|
*/
|
|
void decode_ise(
|
|
quant_method quant_level,
|
|
unsigned int character_count,
|
|
const uint8_t* input_data,
|
|
uint8_t* output_data,
|
|
unsigned int bit_offset);
|
|
|
|
/**
|
|
* @brief Return the number of bits needed to encode an ISE sequence.
|
|
*
|
|
* This implementation assumes that the @c quant level is untrusted, given it may come from random
|
|
* data being decompressed, so we return an arbitrary unencodable size if that is the case.
|
|
*
|
|
* @param character_count The number of items in the sequence.
|
|
* @param quant_level The desired quantization level.
|
|
*
|
|
* @return The number of bits needed to encode the BISE string.
|
|
*/
|
|
unsigned int get_ise_sequence_bitcount(
|
|
unsigned int character_count,
|
|
quant_method quant_level);
|
|
|
|
/* ============================================================================
|
|
Functionality for managing color partitioning.
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief Compute averages and dominant directions for each partition in a 2 component texture.
|
|
*
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to be compressed.
|
|
* @param ewb The image block weighted error data.
|
|
* @param component1 The first component included in the analysis.
|
|
* @param component2 The second component included in the analysis.
|
|
* @param[out] pm The output partition metrics.
|
|
* - Only pi.partition_count array entries actually get initialized.
|
|
* - Direction vectors @c pm.dir are not normalized.
|
|
*/
|
|
void compute_avgs_and_dirs_2_comp(
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
unsigned int component1,
|
|
unsigned int component2,
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]);
|
|
|
|
/**
|
|
* @brief Compute averages and dominant directions for each partition in a 3 component texture.
|
|
*
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to be compressed.
|
|
* @param ewb The image block weighted error data.
|
|
* @param omitted_component The component excluded from the analysis.
|
|
* @param[out] pm The output partition metrics.
|
|
* - Only pi.partition_count array entries actually get initialized.
|
|
* - Direction vectors @c pm.dir are not normalized.
|
|
*/
|
|
void compute_avgs_and_dirs_3_comp(
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
unsigned int omitted_component,
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]);
|
|
|
|
/**
|
|
* @brief Compute averages and dominant directions for each partition in a 4 component texture.
|
|
*
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to be compressed.
|
|
* @param ewb The image block weighted error data.
|
|
* @param[out] pm The output partition metrics.
|
|
* - Only pi.partition_count array entries actually get initialized.
|
|
* - Direction vectors @c pm.dir are not normalized.
|
|
*/
|
|
void compute_avgs_and_dirs_4_comp(
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]);
|
|
|
|
/**
|
|
* @brief Compute the RGB error for uncorrelated and same chroma projections.
|
|
*
|
|
* The output of compute averages and dirs is post processed to define two lines, both of which go
|
|
* through the mean-color-value. One line has a direction defined by the dominant direction; this
|
|
* is used to assess the error from using an uncorrelated color representation. The other line goes
|
|
* through (0,0,0) and is used to assess the error from using an RGBS color representation.
|
|
*
|
|
* This function computes the squared error when using these two representations.
|
|
*
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to be compressed.
|
|
* @param ewb The image block weighted error data.
|
|
* @param[in,out] plines Processed line inputs, and line length outputs.
|
|
* @param[out] uncor_error The cumulative error for using the uncorrelated line.
|
|
* @param[out] samec_error The cumulative error for using the same chroma line.
|
|
*/
|
|
void compute_error_squared_rgb(
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
partition_lines3 plines[BLOCK_MAX_PARTITIONS],
|
|
float& uncor_error,
|
|
float& samec_error);
|
|
|
|
/**
|
|
* @brief Compute the RGBA error for uncorrelated and same chroma projections.
|
|
*
|
|
* The output of compute averages and dirs is post processed to define two lines, both of which go
|
|
* through the mean-color-value. One line has a direction defined by the dominant direction; this
|
|
* is used to assess the error from using an uncorrelated color representation. The other line goes
|
|
* through (0,0,0,1) and is used to assess the error from using an RGBS color representation.
|
|
*
|
|
* This function computes the squared error when using these two representations.
|
|
*
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to be compressed.
|
|
* @param ewb The image block weighted error data.
|
|
* @param uncor_plines Processed uncorrelated partition lines for each partition.
|
|
* @param samec_plines Processed same chroma partition lines for each partition.
|
|
* @param[out] uncor_lengths The length of each components deviation from the line.
|
|
* @param[out] samec_lengths The length of each components deviation from the line.
|
|
* @param[out] uncor_error The cumulative error for using the uncorrelated line.
|
|
* @param[out] samec_error The cumulative error for using the same chroma line.
|
|
*/
|
|
void compute_error_squared_rgba(
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const processed_line4 uncor_plines[BLOCK_MAX_PARTITIONS],
|
|
const processed_line4 samec_plines[BLOCK_MAX_PARTITIONS],
|
|
float uncor_lengths[BLOCK_MAX_PARTITIONS],
|
|
float samec_lengths[BLOCK_MAX_PARTITIONS],
|
|
float& uncor_error,
|
|
float& samec_error);
|
|
|
|
/**
|
|
* @brief Find the best set of partitions to trial for a given block.
|
|
*
|
|
* On return @c best_partition_uncor contains the best partition assuming data has uncorrelated
|
|
* chroma, @c best_partition_samec contains the best partition assuming data has corelated chroma,
|
|
* and* @c best_partition_dualplane contains the best partition assuming the data has one
|
|
* uncorrelated color component. The @c best_partition_dualplane is stored packed; bits [9:0]
|
|
* contain the best partition, bits [11:10] contain the best color component.
|
|
*
|
|
* @param bsd The block size information.
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param partition_count The number of partitions in the block.
|
|
* @param partition_search_limit The number of candidate partition encodings to trial.
|
|
* @param[out] best_partition_uncor The best partition for uncorrelated chroma.
|
|
* @param[out] best_partition_samec The best partition for correlated chroma.
|
|
* @param[out] best_partition_dualplane The best partition for dual plane, but may be @c nullptr.
|
|
*/
|
|
void find_best_partition_candidates(
|
|
const block_size_descriptor& bsd,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
unsigned int partition_count,
|
|
unsigned int partition_search_limit,
|
|
unsigned int& best_partition_uncor,
|
|
unsigned int& best_partition_samec,
|
|
unsigned int* best_partition_dualplane);
|
|
|
|
/* ============================================================================
|
|
Functionality for managing images and image related data.
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief Setup computation of regional averages and variances in an image.
|
|
*
|
|
* This must be done by only a single thread per image, before any thread calls
|
|
* @c compute_averages_and_variances().
|
|
*
|
|
* Results are written back into @c img->input_averages, @c img->input_variances,
|
|
* and @c img->input_alpha_averages.
|
|
*
|
|
* @param img The input image data, also holds output data.
|
|
* @param rgb_power The RGB component power.
|
|
* @param alpha_power The A component power.
|
|
* @param avg_var_kernel_radius The kernel radius (in pixels) for avg and var.
|
|
* @param alpha_kernel_radius The kernel radius (in pixels) for alpha mods.
|
|
* @param swz Input data component swizzle.
|
|
* @param[out] ag The average variance arguments to init.
|
|
*
|
|
* @return The number of tasks in the processing stage.
|
|
*/
|
|
unsigned int init_compute_averages_and_variances(
|
|
const astcenc_image& img,
|
|
float rgb_power,
|
|
float alpha_power,
|
|
unsigned int avg_var_kernel_radius,
|
|
unsigned int alpha_kernel_radius,
|
|
const astcenc_swizzle& swz,
|
|
avg_var_args& ag);
|
|
|
|
/**
|
|
* @brief Compute regional averages and variances.
|
|
*
|
|
* This function can be called by multiple threads, but only after a single thread calls the setup
|
|
* function @c init_compute_averages_and_variances().
|
|
*
|
|
* Results are written back into @c img->input_averages, @c img->input_variances,
|
|
* and @c img->input_alpha_averages.
|
|
*
|
|
* @param[out] ctx The context.
|
|
* @param ag The average and variance arguments created during setup.
|
|
*/
|
|
void compute_averages_and_variances(
|
|
astcenc_context& ctx,
|
|
const avg_var_args& ag);
|
|
|
|
/**
|
|
* @brief Fetch a single image block from the input image
|
|
*
|
|
* @param decode_mode The compression color profile.
|
|
* @param img The input image data.
|
|
* @param[out] blk The image block to populate.
|
|
* @param bsd The block size information.
|
|
* @param xpos The block X coordinate in the input image.
|
|
* @param ypos The block Y coordinate in the input image.
|
|
* @param zpos The block Z coordinate in the input image.
|
|
* @param swz The swizzle to apply on load.
|
|
*/
|
|
void fetch_image_block(
|
|
astcenc_profile decode_mode,
|
|
const astcenc_image& img,
|
|
image_block& blk,
|
|
const block_size_descriptor& bsd,
|
|
unsigned int xpos,
|
|
unsigned int ypos,
|
|
unsigned int zpos,
|
|
const astcenc_swizzle& swz);
|
|
|
|
/**
|
|
* @brief Write a single image block from the output image
|
|
*
|
|
* @param[out] img The input image data.
|
|
* @param blk The image block to populate.
|
|
* @param bsd The block size information.
|
|
* @param xpos The block X coordinate in the input image.
|
|
* @param ypos The block Y coordinate in the input image.
|
|
* @param zpos The block Z coordinate in the input image.
|
|
* @param swz The swizzle to apply on store.
|
|
*/
|
|
void write_image_block(
|
|
astcenc_image& img,
|
|
const image_block& blk,
|
|
const block_size_descriptor& bsd,
|
|
unsigned int xpos,
|
|
unsigned int ypos,
|
|
unsigned int zpos,
|
|
const astcenc_swizzle& swz);
|
|
|
|
/* ============================================================================
|
|
Functionality for computing endpoint colors and weights for a block.
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief Compute ideal endpoint colors and weights for 1 plane of weights.
|
|
*
|
|
* The ideal endpoints define a color line for the partition. For each texel the ideal weight
|
|
* defines an exact position on the partition color line. We can then use these to assess the error
|
|
* introduced by removing and quantizing the weight grid.
|
|
*
|
|
* @param bsd The block size information.
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param pi The partition info for the current trial.
|
|
* @param[out] ei The endpoint and weight values.
|
|
*/
|
|
void compute_ideal_colors_and_weights_1plane(
|
|
const block_size_descriptor& bsd,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const partition_info& pi,
|
|
endpoints_and_weights& ei);
|
|
|
|
/**
|
|
* @brief Compute ideal endpoint colors and weights for 2 planes of weights.
|
|
*
|
|
* The ideal endpoints define a color line for the partition. For each texel the ideal weight
|
|
* defines an exact position on the partition color line. We can then use these to assess the error
|
|
* introduced by removing and quantizing the weight grid.
|
|
*
|
|
* @param bsd The block size information.
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param pi The partition info for the current trial.
|
|
* @param plane2_component The component assigned to plane 2.
|
|
* @param[out] ei1 The endpoint and weight values for plane 1.
|
|
* @param[out] ei2 The endpoint and weight values for plane 2.
|
|
*/
|
|
void compute_ideal_colors_and_weights_2planes(
|
|
const block_size_descriptor& bsd,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const partition_info& pi,
|
|
unsigned int plane2_component,
|
|
endpoints_and_weights& ei1,
|
|
endpoints_and_weights& ei2);
|
|
|
|
/**
|
|
* @brief Compute the optimal unquantized weights for a decimation table.
|
|
*
|
|
* After computing ideal weights for the case for a complete weight grid, we we want to compute the
|
|
* ideal weights for the case where weights exist only for some texels. We do this with a
|
|
* steepest-descent grid solver which works as follows:
|
|
*
|
|
* First, for each actual weight, perform a weighted averaging of the texels affected by the weight.
|
|
* Then, set step size to <some initial value> and attempt one step towards the original ideal
|
|
* weight if it helps to reduce error.
|
|
*
|
|
* @param eai_in The non-decimated endpoints and weights.
|
|
* @param eai_out A copy of eai_in we can modify later for refinement.
|
|
* @param di The selected weight decimation.
|
|
* @param[out] weight_set The output decimated weight set.
|
|
* @param[out] weights The output decimated weights.
|
|
*/
|
|
void compute_ideal_weights_for_decimation(
|
|
const endpoints_and_weights& eai_in,
|
|
endpoints_and_weights& eai_out,
|
|
const decimation_info& di,
|
|
float* weight_set,
|
|
float* weights);
|
|
|
|
/**
|
|
* @brief Compute the optimal quantized weights for a decimation table.
|
|
*
|
|
* We test the two closest weight indices in the allowed quantization range and keep the weight that
|
|
* is the closest match.
|
|
*
|
|
* @param di The selected weight decimation.
|
|
* @param low_bound The lowest weight allowed.
|
|
* @param high_bound The highest weight allowed.
|
|
* @param weight_set_in The ideal weight set.
|
|
* @param[out] weight_set_out The output quantized weight as a float.
|
|
* @param[out] quantized_weight_set The output quantized weight as encoded int.
|
|
* @param quant_level The desired weight quant level.
|
|
*/
|
|
void compute_quantized_weights_for_decimation(
|
|
const decimation_info& di,
|
|
float low_bound,
|
|
float high_bound,
|
|
const float* weight_set_in,
|
|
float* weight_set_out,
|
|
uint8_t* quantized_weight_set,
|
|
quant_method quant_level);
|
|
|
|
/**
|
|
* @brief Compute the infilled weight for a texel index in a decimated grid.
|
|
*/
|
|
static inline float bilinear_infill(
|
|
const decimation_info& di,
|
|
const float* weights,
|
|
unsigned int index
|
|
) {
|
|
return (weights[di.texel_weights_4t[0][index]] * di.texel_weights_float_4t[0][index] +
|
|
weights[di.texel_weights_4t[1][index]] * di.texel_weights_float_4t[1][index]) +
|
|
(weights[di.texel_weights_4t[2][index]] * di.texel_weights_float_4t[2][index] +
|
|
weights[di.texel_weights_4t[3][index]] * di.texel_weights_float_4t[3][index]);
|
|
}
|
|
|
|
/**
|
|
* @brief Compute the infilled weight for N texel indices in a decimated grid.
|
|
*/
|
|
static inline vfloat bilinear_infill_vla(
|
|
const decimation_info& di,
|
|
const float* weights,
|
|
unsigned int index
|
|
) {
|
|
// Load the bilinear filter texel weight indexes in the decimated grid
|
|
vint weight_idx0 = vint(di.texel_weights_4t[0] + index);
|
|
vint weight_idx1 = vint(di.texel_weights_4t[1] + index);
|
|
vint weight_idx2 = vint(di.texel_weights_4t[2] + index);
|
|
vint weight_idx3 = vint(di.texel_weights_4t[3] + index);
|
|
|
|
// Load the bilinear filter weights from the decimated grid
|
|
vfloat weight_val0 = gatherf(weights, weight_idx0);
|
|
vfloat weight_val1 = gatherf(weights, weight_idx1);
|
|
vfloat weight_val2 = gatherf(weights, weight_idx2);
|
|
vfloat weight_val3 = gatherf(weights, weight_idx3);
|
|
|
|
// Load the weight contribution factors for each decimated weight
|
|
vfloat tex_weight_float0 = loada(di.texel_weights_float_4t[0] + index);
|
|
vfloat tex_weight_float1 = loada(di.texel_weights_float_4t[1] + index);
|
|
vfloat tex_weight_float2 = loada(di.texel_weights_float_4t[2] + index);
|
|
vfloat tex_weight_float3 = loada(di.texel_weights_float_4t[3] + index);
|
|
|
|
// Compute the bilinear interpolation to generate the per-texel weight
|
|
return (weight_val0 * tex_weight_float0 + weight_val1 * tex_weight_float1) +
|
|
(weight_val2 * tex_weight_float2 + weight_val3 * tex_weight_float3);
|
|
}
|
|
|
|
/**
|
|
* @brief Compute the error of a decimated weight set for 1 plane.
|
|
*
|
|
* After computing ideal weights for the case with one weight per texel, we want to compute the
|
|
* error for decimated weight grids where weights are stored at a lower resolution. This function
|
|
* computes the error of the reduced grid, compared to the full grid.
|
|
*
|
|
* @param eai The ideal weights for the full grid.
|
|
* @param di The selected weight decimation.
|
|
* @param weights The ideal weights for the decimated grid.
|
|
*
|
|
* @return The accumulated error.
|
|
*/
|
|
float compute_error_of_weight_set_1plane(
|
|
const endpoints_and_weights& eai,
|
|
const decimation_info& di,
|
|
const float *weights);
|
|
|
|
/**
|
|
* @brief Compute the error of a decimated weight set for 2 planes.
|
|
*
|
|
* After computing ideal weights for the case with one weight per texel, we want to compute the
|
|
* error for decimated weight grids where weights are stored at a lower resolution. This function
|
|
* computes the error of the reduced grid, compared to the full grid.
|
|
*
|
|
* @param eai1 The ideal weights for the full grid and plane 1.
|
|
* @param eai2 The ideal weights for the full grid and plane 2.
|
|
* @param di The selected weight decimation.
|
|
* @param weights1 The ideal weights for the decimated grid plane 1.
|
|
* @param weights2 The ideal weights for the decimated grid plane 2.
|
|
*
|
|
* @return The accumulated error.
|
|
*/
|
|
float compute_error_of_weight_set_2planes(
|
|
const endpoints_and_weights& eai1,
|
|
const endpoints_and_weights& eai2,
|
|
const decimation_info& di,
|
|
const float* weights1,
|
|
const float* weights2);
|
|
|
|
/**
|
|
* @brief Pack a single pair of color endpoints as effectively as possible.
|
|
*
|
|
* The user requests a base color endpoint mode in @c format, but the quantizer may choose a
|
|
* delta-based representation. It will report back the format variant it actually used.
|
|
*
|
|
* @param color0 The input unquantized color0 endpoint for absolute endpoint pairs.
|
|
* @param color1 The input unquantized color1 endpoint for absolute endpoint pairs.
|
|
* @param rgbs_color The input unquantized RGBS variant endpoint for same chroma endpoints.
|
|
* @param rgbo_color The input unquantized RGBS variant endpoint for HDR endpoints..
|
|
* @param format The desired base format.
|
|
* @param[out] output The output storage for the quantized colors/
|
|
* @param quant_level The quantization level requested.
|
|
*
|
|
* @return The actual endpoint mode used.
|
|
*/
|
|
// TODO: Format as enum?
|
|
int pack_color_endpoints(
|
|
vfloat4 color0,
|
|
vfloat4 color1,
|
|
vfloat4 rgbs_color,
|
|
vfloat4 rgbo_color,
|
|
int format,
|
|
uint8_t* output,
|
|
quant_method quant_level);
|
|
|
|
/**
|
|
* @brief Unpack a single pair of encoded and quantized color endpoints.
|
|
*
|
|
* @param decode_mode The decode mode (LDR, HDR).
|
|
* @param format The color endpoint mode used.
|
|
* @param quant_level The quantization level used.
|
|
* @param input The raw array of encoded input integers. The length of this array
|
|
* depends on @c format; it can be safely assumed to be large enough.
|
|
* @param[out] rgb_hdr Is the endpoint using HDR for the RGB channels?
|
|
* @param[out] alpha_hdr Is the endpoint using HDR for the A channel?
|
|
* @param[out] output0 The output color for endpoint 0.
|
|
* @param[out] output1 The output color for endpoint 1.
|
|
*/
|
|
// TODO: Format as enum?
|
|
void unpack_color_endpoints(
|
|
astcenc_profile decode_mode,
|
|
int format,
|
|
quant_method quant_level,
|
|
const uint8_t* input,
|
|
bool& rgb_hdr,
|
|
bool& alpha_hdr,
|
|
vint4& output0,
|
|
vint4& output1);
|
|
|
|
/**
|
|
* @brief Unpack a set of quantized and decimated weights.
|
|
*
|
|
* @param bsd The block size information.
|
|
* @param scb The symbolic compressed encoding.
|
|
* @param di The weight grid decimation table.
|
|
* @param is_dual_plane @c true if this is a dual plane block, @c false otherwise.
|
|
* @param quant_level The weight quantization level.
|
|
* @param[out] weights_plane1 The output array for storing the plane 1 weights.
|
|
* @param[out] weights_plane2 The output array for storing the plane 2 weights.
|
|
*/
|
|
void unpack_weights(
|
|
const block_size_descriptor& bsd,
|
|
const symbolic_compressed_block& scb,
|
|
const decimation_info& di,
|
|
bool is_dual_plane,
|
|
quant_method quant_level,
|
|
int weights_plane1[BLOCK_MAX_TEXELS],
|
|
int weights_plane2[BLOCK_MAX_TEXELS]);
|
|
|
|
/**
|
|
* @brief Identify, for each mode, which set of color endpoint produces the best result.
|
|
*
|
|
* Returns the best @c tune_candidate_limit best looking modes, along with the ideal color encoding
|
|
* combination for each. The modified quantization level can be used when all formats are the same,
|
|
* as this frees up two additional bits of storage.
|
|
*
|
|
* @param bsd The block size information.
|
|
* @param pi The partition info for the current trial.
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param ep The ideal endpoints.
|
|
* @param qwt_bitcounts Bit counts for different quantization methods.
|
|
* @param qwt_errors Errors for different quantization methods.
|
|
* @param tune_candidate_limit The max number of candidates to return, may be less.
|
|
* @param[out] partition_format_specifiers The best formats per partition.
|
|
* @param[out] block_mode The best packed block mode indexes.
|
|
* @param[out] quant_level The best color quant level.
|
|
* @param[out] quant_level_mod The best color quant level if endpoints are the same.
|
|
*
|
|
* @return The actual number of candidate matches returned.
|
|
*/
|
|
unsigned int compute_ideal_endpoint_formats(
|
|
const block_size_descriptor& bsd,
|
|
const partition_info& pi,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const endpoints& ep,
|
|
const int* qwt_bitcounts,
|
|
const float* qwt_errors,
|
|
unsigned int tune_candidate_limit,
|
|
int partition_format_specifiers[TUNE_MAX_TRIAL_CANDIDATES][BLOCK_MAX_PARTITIONS],
|
|
int block_mode[TUNE_MAX_TRIAL_CANDIDATES],
|
|
quant_method quant_level[TUNE_MAX_TRIAL_CANDIDATES],
|
|
quant_method quant_level_mod[TUNE_MAX_TRIAL_CANDIDATES]);
|
|
|
|
/**
|
|
* @brief For a given 1 plane weight set recompute the endpoint colors.
|
|
*
|
|
* As we quantize and decimate weights the optimal endpoint colors may change slightly, so we must
|
|
* recompute the ideal colors for a specific weight set.
|
|
*
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param pi The partition info for the current trial.
|
|
* @param di The weight grid decimation table.
|
|
* @param weight_quant_mode The weight grid quantization level.
|
|
* @param weight_set8 The quantized weight set.
|
|
* @param[in,out] ep The color endpoints (modifed in place).
|
|
* @param[out] rgbs_vectors The RGB+scale vectors for LDR blocks.
|
|
* @param[out] rgbo_vectors The RGB+offset vectors for HDR blocks.
|
|
*/
|
|
void recompute_ideal_colors_1plane(
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const partition_info& pi,
|
|
const decimation_info& di,
|
|
int weight_quant_mode,
|
|
const uint8_t* weight_set8,
|
|
endpoints& ep,
|
|
vfloat4 rgbs_vectors[BLOCK_MAX_PARTITIONS],
|
|
vfloat4 rgbo_vectors[BLOCK_MAX_PARTITIONS]);
|
|
|
|
/**
|
|
* @brief For a given 2 plane weight set recompute the endpoint colors.
|
|
*
|
|
* As we quantize and decimate weights the optimal endpoint colors may change slightly, so we must
|
|
* recompute the ideal colors for a specific weight set.
|
|
*
|
|
* @param blk The image block color data to compress.
|
|
* @param ewb The image block weighted error data.
|
|
* @param pi The partition info for the current trial.
|
|
* @param di The weight grid decimation table.
|
|
* @param weight_quant_mode The weight grid quantization level.
|
|
* @param weight_set8_plane1 The quantized weight set for plane 1.
|
|
* @param weight_set8_plane2 The quantized weight set for plane 2.
|
|
* @param[in,out] ep The color endpoints (modifed in place).
|
|
* @param[out] rgbs_vectors The RGB+scale vectors for LDR blocks.
|
|
* @param[out] rgbo_vectors The RGB+offset vectors for HDR blocks.
|
|
* @param plane2_component The component assigned to plane 2.
|
|
*/
|
|
void recompute_ideal_colors_2planes(
|
|
const image_block& blk,
|
|
const error_weight_block& ewb,
|
|
const partition_info& pi,
|
|
const decimation_info& di,
|
|
int weight_quant_mode,
|
|
const uint8_t* weight_set8_plane1,
|
|
const uint8_t* weight_set8_plane2,
|
|
endpoints& ep,
|
|
vfloat4 rgbs_vectors[BLOCK_MAX_PARTITIONS],
|
|
vfloat4 rgbo_vectors[BLOCK_MAX_PARTITIONS],
|
|
int plane2_component);
|
|
|
|
void expand_deblock_weights(
|
|
astcenc_context& ctx);
|
|
|
|
// functions pertaining to weight alignment
|
|
void prepare_angular_tables();
|
|
|
|
void compute_angular_endpoints_1plane(
|
|
bool only_always,
|
|
const block_size_descriptor& bsd,
|
|
const float* decimated_quantized_weights,
|
|
const float* decimated_weights,
|
|
float low_value[WEIGHTS_MAX_BLOCK_MODES],
|
|
float high_value[WEIGHTS_MAX_BLOCK_MODES]);
|
|
|
|
void compute_angular_endpoints_2planes(
|
|
const block_size_descriptor& bsd,
|
|
const float* decimated_quantized_weights,
|
|
const float* decimated_weights,
|
|
float low_value1[WEIGHTS_MAX_BLOCK_MODES],
|
|
float high_value1[WEIGHTS_MAX_BLOCK_MODES],
|
|
float low_value2[WEIGHTS_MAX_BLOCK_MODES],
|
|
float high_value2[WEIGHTS_MAX_BLOCK_MODES]);
|
|
|
|
/* ============================================================================
|
|
Functionality for high level compression and decompression access.
|
|
============================================================================ */
|
|
|
|
/**
|
|
* @brief Compress an image block into a physical block.
|
|
*
|
|
* @param ctx The compressor context and configuration.
|
|
* @param image The input image information.
|
|
* @param blk The image block color data to compress.
|
|
* @param[out] pcb The physical compressed block output.
|
|
* @param[out] tmpbuf Preallocated scratch buffers for the compressor.
|
|
*/
|
|
void compress_block(
|
|
const astcenc_context& ctx,
|
|
const astcenc_image& image,
|
|
const image_block& blk,
|
|
physical_compressed_block& pcb,
|
|
compression_working_buffers& tmpbuf);
|
|
|
|
/**
|
|
* @brief Decompress a symbolic block in to an image block.
|
|
*
|
|
* @param decode_mode The decode mode (LDR, HDR, etc).
|
|
* @param bsd The block size information.
|
|
* @param xpos The X coordinate of the block in the overall image.
|
|
* @param ypos The Y coordinate of the block in the overall image.
|
|
* @param zpos The Z coordinate of the block in the overall image.
|
|
* @param[out] blk The decompressed image block color data.
|
|
*/
|
|
void decompress_symbolic_block(
|
|
astcenc_profile decode_mode,
|
|
const block_size_descriptor& bsd,
|
|
int xpos,
|
|
int ypos,
|
|
int zpos,
|
|
const symbolic_compressed_block& scb,
|
|
image_block& blk);
|
|
|
|
/**
|
|
* @brief Compute the error between a symbolic block and the original input data.
|
|
*
|
|
* In RGBM mode this will reject blocks that attempt to encode a zero M value.
|
|
*
|
|
* @param config The compressor config.
|
|
* @param bsd The block size information.
|
|
* @param scb The symbolic compressed encoding.
|
|
* @param blk The original image block color data.
|
|
* @param ewb The error weight block data.
|
|
*
|
|
* @return Returns the computed error, or a negative value if the encoding
|
|
* should be rejected for any reason.
|
|
*/
|
|
float compute_symbolic_block_difference(
|
|
const astcenc_config& config,
|
|
const block_size_descriptor& bsd,
|
|
const symbolic_compressed_block& scb,
|
|
const image_block& blk,
|
|
const error_weight_block& ewb) ;
|
|
|
|
void symbolic_to_physical(
|
|
const block_size_descriptor& bsd,
|
|
const symbolic_compressed_block& scb,
|
|
physical_compressed_block& pcb);
|
|
|
|
void physical_to_symbolic(
|
|
const block_size_descriptor& bsd,
|
|
const physical_compressed_block& pcb,
|
|
symbolic_compressed_block& scb);
|
|
|
|
/* ============================================================================
|
|
Platform-specific functions.
|
|
============================================================================ */
|
|
/**
|
|
* @brief Run-time detection if the host CPU supports the POPCNT extension.
|
|
*
|
|
* @return @c true if supported, @c false if not.
|
|
*/
|
|
bool cpu_supports_popcnt();
|
|
|
|
/**
|
|
* @brief Run-time detection if the host CPU supports F16C extension.
|
|
*
|
|
* @return @c true if supported, @c false if not.
|
|
*/
|
|
bool cpu_supports_f16c();
|
|
|
|
/**
|
|
* @brief Run-time detection if the host CPU supports SSE 4.1 extension.
|
|
*
|
|
* @return @c true if supported, @c false if not.
|
|
*/
|
|
bool cpu_supports_sse41();
|
|
|
|
/**
|
|
* @brief Run-time detection if the host CPU supports AVX 2 extension.
|
|
*
|
|
* @return @c true if supported, @c false if not.
|
|
*/
|
|
bool cpu_supports_avx2();
|
|
|
|
/**
|
|
* @brief Allocate an aligned memory buffer.
|
|
*
|
|
* Allocated memory must be freed by aligned_free;
|
|
*
|
|
* @param size The desired buffer size.
|
|
* @param align The desired buffer alignment; must be 2^N.
|
|
*
|
|
* @return The memory buffer pointer or nullptr on allocation failure.
|
|
*/
|
|
template<typename T>
|
|
T* aligned_malloc(size_t size, size_t align)
|
|
{
|
|
void* ptr;
|
|
int error = 0;
|
|
|
|
#if defined(_WIN32)
|
|
ptr = _aligned_malloc(size, align);
|
|
#else
|
|
error = posix_memalign(&ptr, align, size);
|
|
#endif
|
|
|
|
if (error || (!ptr))
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
return static_cast<T*>(ptr);
|
|
}
|
|
|
|
/**
|
|
* @brief Free an aligned memory buffer.
|
|
*
|
|
* @param ptr The buffer to free.
|
|
*/
|
|
template<typename T>
|
|
void aligned_free(T* ptr)
|
|
{
|
|
#if defined(_WIN32)
|
|
_aligned_free((void*)ptr);
|
|
#else
|
|
free((void*)ptr);
|
|
#endif
|
|
}
|
|
|
|
#endif
|