996 lines
33 KiB
C++
996 lines
33 KiB
C++
|
// SPDX-License-Identifier: Apache-2.0
|
||
|
|
// ----------------------------------------------------------------------------
|
||
|
|
// Copyright 2011-2022 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 for finding dominant direction of a set of colors.
|
||
|
|
*/
|
||
|
|
#if !defined(ASTCENC_DECOMPRESS_ONLY)
|
||
|
|
|
||
|
|
#include "astcenc_internal.h"
|
||
|
|
|
||
|
|
#include <cassert>
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Compute the average RGB color of each partition.
|
||
|
|
*
|
||
|
|
* The algorithm here uses a vectorized sequential scan and per-partition
|
||
|
|
* color accumulators, using select() to mask texel lanes in other partitions.
|
||
|
|
*
|
||
|
|
* We only accumulate sums for N-1 partitions during the scan; the value for
|
||
|
|
* the last partition can be computed given that we know the block-wide average
|
||
|
|
* already.
|
||
|
|
*
|
||
|
|
* Because of this we could reduce the loop iteration count so it "just" spans
|
||
|
|
* the max texel index needed for the N-1 partitions, which could need fewer
|
||
|
|
* iterations than the full block texel count. However, this makes the loop
|
||
|
|
* count erratic and causes more branch mispredictions so is a net loss.
|
||
|
|
*
|
||
|
|
* @param pi The partitioning to use.
|
||
|
|
* @param blk The block data to process.
|
||
|
|
* @param[out] averages The output averages. Unused partition indices will
|
||
|
|
* not be initialized, and lane<3> will be zero.
|
||
|
|
*/
|
||
|
|
static void compute_partition_averages_rgb(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
vfloat4 averages[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
unsigned int texel_count = blk.texel_count;
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
// For 1 partition just use the precomputed mean
|
||
|
|
if (partition_count == 1)
|
||
|
|
{
|
||
|
|
averages[0] = blk.data_mean.swz<0, 1, 2>();
|
||
|
|
}
|
||
|
|
// For 2 partitions scan results for partition 0, compute partition 1
|
||
|
|
else if (partition_count == 2)
|
||
|
|
{
|
||
|
|
vfloatacc pp_avg_rgb[3] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgb[0], data_r, p0_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgb[1], data_g, p0_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgb[2], data_b, p0_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean.swz<0, 1, 2>() * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat3(hadd_s(pp_avg_rgb[0]),
|
||
|
|
hadd_s(pp_avg_rgb[1]),
|
||
|
|
hadd_s(pp_avg_rgb[2]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = block_total - p0_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
}
|
||
|
|
// For 3 partitions scan results for partition 0/1, compute partition 2
|
||
|
|
else if (partition_count == 3)
|
||
|
|
{
|
||
|
|
vfloatacc pp_avg_rgb[2][3] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
vmask p1_mask = lane_mask & (texel_partition == vint(1));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][0], data_r, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][0], data_r, p1_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][1], data_g, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][1], data_g, p1_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][2], data_b, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][2], data_b, p1_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean.swz<0, 1, 2>() * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat3(hadd_s(pp_avg_rgb[0][0]),
|
||
|
|
hadd_s(pp_avg_rgb[0][1]),
|
||
|
|
hadd_s(pp_avg_rgb[0][2]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = vfloat3(hadd_s(pp_avg_rgb[1][0]),
|
||
|
|
hadd_s(pp_avg_rgb[1][1]),
|
||
|
|
hadd_s(pp_avg_rgb[1][2]));
|
||
|
|
|
||
|
|
vfloat4 p2_total = block_total - p0_total - p1_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
averages[2] = p2_total / static_cast<float>(pi.partition_texel_count[2]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// For 4 partitions scan results for partition 0/1/2, compute partition 3
|
||
|
|
vfloatacc pp_avg_rgb[3][3] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
vmask p1_mask = lane_mask & (texel_partition == vint(1));
|
||
|
|
vmask p2_mask = lane_mask & (texel_partition == vint(2));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][0], data_r, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][0], data_r, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgb[2][0], data_r, p2_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][1], data_g, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][1], data_g, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgb[2][1], data_g, p2_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgb[0][2], data_b, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgb[1][2], data_b, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgb[2][2], data_b, p2_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean.swz<0, 1, 2>() * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat3(hadd_s(pp_avg_rgb[0][0]),
|
||
|
|
hadd_s(pp_avg_rgb[0][1]),
|
||
|
|
hadd_s(pp_avg_rgb[0][2]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = vfloat3(hadd_s(pp_avg_rgb[1][0]),
|
||
|
|
hadd_s(pp_avg_rgb[1][1]),
|
||
|
|
hadd_s(pp_avg_rgb[1][2]));
|
||
|
|
|
||
|
|
vfloat4 p2_total = vfloat3(hadd_s(pp_avg_rgb[2][0]),
|
||
|
|
hadd_s(pp_avg_rgb[2][1]),
|
||
|
|
hadd_s(pp_avg_rgb[2][2]));
|
||
|
|
|
||
|
|
vfloat4 p3_total = block_total - p0_total - p1_total- p2_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
averages[2] = p2_total / static_cast<float>(pi.partition_texel_count[2]);
|
||
|
|
averages[3] = p3_total / static_cast<float>(pi.partition_texel_count[3]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Compute the average RGBA color of each partition.
|
||
|
|
*
|
||
|
|
* The algorithm here uses a vectorized sequential scan and per-partition
|
||
|
|
* color accumulators, using select() to mask texel lanes in other partitions.
|
||
|
|
*
|
||
|
|
* We only accumulate sums for N-1 partitions during the scan; the value for
|
||
|
|
* the last partition can be computed given that we know the block-wide average
|
||
|
|
* already.
|
||
|
|
*
|
||
|
|
* Because of this we could reduce the loop iteration count so it "just" spans
|
||
|
|
* the max texel index needed for the N-1 partitions, which could need fewer
|
||
|
|
* iterations than the full block texel count. However, this makes the loop
|
||
|
|
* count erratic and causes more branch mispredictions so is a net loss.
|
||
|
|
*
|
||
|
|
* @param pi The partitioning to use.
|
||
|
|
* @param blk The block data to process.
|
||
|
|
* @param[out] averages The output averages. Unused partition indices will
|
||
|
|
* not be initialized.
|
||
|
|
*/
|
||
|
|
static void compute_partition_averages_rgba(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
vfloat4 averages[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
unsigned int texel_count = blk.texel_count;
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
// For 1 partition just use the precomputed mean
|
||
|
|
if (partition_count == 1)
|
||
|
|
{
|
||
|
|
averages[0] = blk.data_mean;
|
||
|
|
}
|
||
|
|
// For 2 partitions scan results for partition 0, compute partition 1
|
||
|
|
else if (partition_count == 2)
|
||
|
|
{
|
||
|
|
vfloat4 pp_avg_rgba[4] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgba[0], data_r, p0_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgba[1], data_g, p0_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgba[2], data_b, p0_mask);
|
||
|
|
|
||
|
|
vfloat data_a = loada(blk.data_a + i);
|
||
|
|
haccumulate(pp_avg_rgba[3], data_a, p0_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat4(hadd_s(pp_avg_rgba[0]),
|
||
|
|
hadd_s(pp_avg_rgba[1]),
|
||
|
|
hadd_s(pp_avg_rgba[2]),
|
||
|
|
hadd_s(pp_avg_rgba[3]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = block_total - p0_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
}
|
||
|
|
// For 3 partitions scan results for partition 0/1, compute partition 2
|
||
|
|
else if (partition_count == 3)
|
||
|
|
{
|
||
|
|
vfloat4 pp_avg_rgba[2][4] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
vmask p1_mask = lane_mask & (texel_partition == vint(1));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][0], data_r, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][0], data_r, p1_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][1], data_g, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][1], data_g, p1_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][2], data_b, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][2], data_b, p1_mask);
|
||
|
|
|
||
|
|
vfloat data_a = loada(blk.data_a + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][3], data_a, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][3], data_a, p1_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat4(hadd_s(pp_avg_rgba[0][0]),
|
||
|
|
hadd_s(pp_avg_rgba[0][1]),
|
||
|
|
hadd_s(pp_avg_rgba[0][2]),
|
||
|
|
hadd_s(pp_avg_rgba[0][3]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = vfloat4(hadd_s(pp_avg_rgba[1][0]),
|
||
|
|
hadd_s(pp_avg_rgba[1][1]),
|
||
|
|
hadd_s(pp_avg_rgba[1][2]),
|
||
|
|
hadd_s(pp_avg_rgba[1][3]));
|
||
|
|
|
||
|
|
vfloat4 p2_total = block_total - p0_total - p1_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
averages[2] = p2_total / static_cast<float>(pi.partition_texel_count[2]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// For 4 partitions scan results for partition 0/1/2, compute partition 3
|
||
|
|
vfloat4 pp_avg_rgba[3][4] {};
|
||
|
|
|
||
|
|
vint lane_id = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vint texel_partition(pi.partition_of_texel + i);
|
||
|
|
|
||
|
|
vmask lane_mask = lane_id < vint(texel_count);
|
||
|
|
lane_id += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
|
||
|
|
vmask p0_mask = lane_mask & (texel_partition == vint(0));
|
||
|
|
vmask p1_mask = lane_mask & (texel_partition == vint(1));
|
||
|
|
vmask p2_mask = lane_mask & (texel_partition == vint(2));
|
||
|
|
|
||
|
|
vfloat data_r = loada(blk.data_r + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][0], data_r, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][0], data_r, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgba[2][0], data_r, p2_mask);
|
||
|
|
|
||
|
|
vfloat data_g = loada(blk.data_g + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][1], data_g, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][1], data_g, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgba[2][1], data_g, p2_mask);
|
||
|
|
|
||
|
|
vfloat data_b = loada(blk.data_b + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][2], data_b, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][2], data_b, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgba[2][2], data_b, p2_mask);
|
||
|
|
|
||
|
|
vfloat data_a = loada(blk.data_a + i);
|
||
|
|
haccumulate(pp_avg_rgba[0][3], data_a, p0_mask);
|
||
|
|
haccumulate(pp_avg_rgba[1][3], data_a, p1_mask);
|
||
|
|
haccumulate(pp_avg_rgba[2][3], data_a, p2_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 block_total = blk.data_mean * static_cast<float>(blk.texel_count);
|
||
|
|
|
||
|
|
vfloat4 p0_total = vfloat4(hadd_s(pp_avg_rgba[0][0]),
|
||
|
|
hadd_s(pp_avg_rgba[0][1]),
|
||
|
|
hadd_s(pp_avg_rgba[0][2]),
|
||
|
|
hadd_s(pp_avg_rgba[0][3]));
|
||
|
|
|
||
|
|
vfloat4 p1_total = vfloat4(hadd_s(pp_avg_rgba[1][0]),
|
||
|
|
hadd_s(pp_avg_rgba[1][1]),
|
||
|
|
hadd_s(pp_avg_rgba[1][2]),
|
||
|
|
hadd_s(pp_avg_rgba[1][3]));
|
||
|
|
|
||
|
|
vfloat4 p2_total = vfloat4(hadd_s(pp_avg_rgba[2][0]),
|
||
|
|
hadd_s(pp_avg_rgba[2][1]),
|
||
|
|
hadd_s(pp_avg_rgba[2][2]),
|
||
|
|
hadd_s(pp_avg_rgba[2][3]));
|
||
|
|
|
||
|
|
vfloat4 p3_total = block_total - p0_total - p1_total- p2_total;
|
||
|
|
|
||
|
|
averages[0] = p0_total / static_cast<float>(pi.partition_texel_count[0]);
|
||
|
|
averages[1] = p1_total / static_cast<float>(pi.partition_texel_count[1]);
|
||
|
|
averages[2] = p2_total / static_cast<float>(pi.partition_texel_count[2]);
|
||
|
|
averages[3] = p3_total / static_cast<float>(pi.partition_texel_count[3]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_avgs_and_dirs_4_comp(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
int partition_count = pi.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
// Pre-compute partition_averages
|
||
|
|
vfloat4 partition_averages[BLOCK_MAX_PARTITIONS];
|
||
|
|
compute_partition_averages_rgba(pi, blk, partition_averages);
|
||
|
|
|
||
|
|
for (int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
const uint8_t *texel_indexes = pi.texels_of_partition[partition];
|
||
|
|
unsigned int texel_count = pi.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
vfloat4 average = partition_averages[partition];
|
||
|
|
pm[partition].avg = average;
|
||
|
|
|
||
|
|
vfloat4 sum_xp = vfloat4::zero();
|
||
|
|
vfloat4 sum_yp = vfloat4::zero();
|
||
|
|
vfloat4 sum_zp = vfloat4::zero();
|
||
|
|
vfloat4 sum_wp = vfloat4::zero();
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < texel_count; i++)
|
||
|
|
{
|
||
|
|
unsigned int iwt = texel_indexes[i];
|
||
|
|
vfloat4 texel_datum = blk.texel(iwt);
|
||
|
|
texel_datum = texel_datum - average;
|
||
|
|
|
||
|
|
vfloat4 zero = vfloat4::zero();
|
||
|
|
|
||
|
|
vmask4 tdm0 = texel_datum.swz<0,0,0,0>() > zero;
|
||
|
|
sum_xp += select(zero, texel_datum, tdm0);
|
||
|
|
|
||
|
|
vmask4 tdm1 = texel_datum.swz<1,1,1,1>() > zero;
|
||
|
|
sum_yp += select(zero, texel_datum, tdm1);
|
||
|
|
|
||
|
|
vmask4 tdm2 = texel_datum.swz<2,2,2,2>() > zero;
|
||
|
|
sum_zp += select(zero, texel_datum, tdm2);
|
||
|
|
|
||
|
|
vmask4 tdm3 = texel_datum.swz<3,3,3,3>() > zero;
|
||
|
|
sum_wp += select(zero, texel_datum, tdm3);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 prod_xp = dot(sum_xp, sum_xp);
|
||
|
|
vfloat4 prod_yp = dot(sum_yp, sum_yp);
|
||
|
|
vfloat4 prod_zp = dot(sum_zp, sum_zp);
|
||
|
|
vfloat4 prod_wp = dot(sum_wp, sum_wp);
|
||
|
|
|
||
|
|
vfloat4 best_vector = sum_xp;
|
||
|
|
vfloat4 best_sum = prod_xp;
|
||
|
|
|
||
|
|
vmask4 mask = prod_yp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_yp, mask);
|
||
|
|
best_sum = select(best_sum, prod_yp, mask);
|
||
|
|
|
||
|
|
mask = prod_zp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_zp, mask);
|
||
|
|
best_sum = select(best_sum, prod_zp, mask);
|
||
|
|
|
||
|
|
mask = prod_wp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_wp, mask);
|
||
|
|
|
||
|
|
pm[partition].dir = best_vector;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_avgs_and_dirs_3_comp(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
unsigned int omitted_component,
|
||
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
// Pre-compute partition_averages
|
||
|
|
vfloat4 partition_averages[BLOCK_MAX_PARTITIONS];
|
||
|
|
compute_partition_averages_rgba(pi, blk, partition_averages);
|
||
|
|
|
||
|
|
const float* data_vr = blk.data_r;
|
||
|
|
const float* data_vg = blk.data_g;
|
||
|
|
const float* data_vb = blk.data_b;
|
||
|
|
|
||
|
|
// TODO: Data-driven permute would be useful to avoid this ...
|
||
|
|
if (omitted_component == 0)
|
||
|
|
{
|
||
|
|
partition_averages[0] = partition_averages[0].swz<1, 2, 3>();
|
||
|
|
partition_averages[1] = partition_averages[1].swz<1, 2, 3>();
|
||
|
|
partition_averages[2] = partition_averages[2].swz<1, 2, 3>();
|
||
|
|
partition_averages[3] = partition_averages[3].swz<1, 2, 3>();
|
||
|
|
|
||
|
|
data_vr = blk.data_g;
|
||
|
|
data_vg = blk.data_b;
|
||
|
|
data_vb = blk.data_a;
|
||
|
|
}
|
||
|
|
else if (omitted_component == 1)
|
||
|
|
{
|
||
|
|
partition_averages[0] = partition_averages[0].swz<0, 2, 3>();
|
||
|
|
partition_averages[1] = partition_averages[1].swz<0, 2, 3>();
|
||
|
|
partition_averages[2] = partition_averages[2].swz<0, 2, 3>();
|
||
|
|
partition_averages[3] = partition_averages[3].swz<0, 2, 3>();
|
||
|
|
|
||
|
|
data_vg = blk.data_b;
|
||
|
|
data_vb = blk.data_a;
|
||
|
|
}
|
||
|
|
else if (omitted_component == 2)
|
||
|
|
{
|
||
|
|
partition_averages[0] = partition_averages[0].swz<0, 1, 3>();
|
||
|
|
partition_averages[1] = partition_averages[1].swz<0, 1, 3>();
|
||
|
|
partition_averages[2] = partition_averages[2].swz<0, 1, 3>();
|
||
|
|
partition_averages[3] = partition_averages[3].swz<0, 1, 3>();
|
||
|
|
|
||
|
|
data_vb = blk.data_a;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
partition_averages[0] = partition_averages[0].swz<0, 1, 2>();
|
||
|
|
partition_averages[1] = partition_averages[1].swz<0, 1, 2>();
|
||
|
|
partition_averages[2] = partition_averages[2].swz<0, 1, 2>();
|
||
|
|
partition_averages[3] = partition_averages[3].swz<0, 1, 2>();
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
for (unsigned int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
const uint8_t *texel_indexes = pi.texels_of_partition[partition];
|
||
|
|
unsigned int texel_count = pi.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
vfloat4 average = partition_averages[partition];
|
||
|
|
pm[partition].avg = average;
|
||
|
|
|
||
|
|
vfloat4 sum_xp = vfloat4::zero();
|
||
|
|
vfloat4 sum_yp = vfloat4::zero();
|
||
|
|
vfloat4 sum_zp = vfloat4::zero();
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < texel_count; i++)
|
||
|
|
{
|
||
|
|
unsigned int iwt = texel_indexes[i];
|
||
|
|
|
||
|
|
vfloat4 texel_datum = vfloat3(data_vr[iwt],
|
||
|
|
data_vg[iwt],
|
||
|
|
data_vb[iwt]);
|
||
|
|
texel_datum = texel_datum - average;
|
||
|
|
|
||
|
|
vfloat4 zero = vfloat4::zero();
|
||
|
|
|
||
|
|
vmask4 tdm0 = texel_datum.swz<0,0,0,0>() > zero;
|
||
|
|
sum_xp += select(zero, texel_datum, tdm0);
|
||
|
|
|
||
|
|
vmask4 tdm1 = texel_datum.swz<1,1,1,1>() > zero;
|
||
|
|
sum_yp += select(zero, texel_datum, tdm1);
|
||
|
|
|
||
|
|
vmask4 tdm2 = texel_datum.swz<2,2,2,2>() > zero;
|
||
|
|
sum_zp += select(zero, texel_datum, tdm2);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 prod_xp = dot(sum_xp, sum_xp);
|
||
|
|
vfloat4 prod_yp = dot(sum_yp, sum_yp);
|
||
|
|
vfloat4 prod_zp = dot(sum_zp, sum_zp);
|
||
|
|
|
||
|
|
vfloat4 best_vector = sum_xp;
|
||
|
|
vfloat4 best_sum = prod_xp;
|
||
|
|
|
||
|
|
vmask4 mask = prod_yp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_yp, mask);
|
||
|
|
best_sum = select(best_sum, prod_yp, mask);
|
||
|
|
|
||
|
|
mask = prod_zp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_zp, mask);
|
||
|
|
|
||
|
|
pm[partition].dir = best_vector;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_avgs_and_dirs_3_comp_rgb(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
// Pre-compute partition_averages
|
||
|
|
vfloat4 partition_averages[BLOCK_MAX_PARTITIONS];
|
||
|
|
compute_partition_averages_rgb(pi, blk, partition_averages);
|
||
|
|
|
||
|
|
for (unsigned int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
const uint8_t *texel_indexes = pi.texels_of_partition[partition];
|
||
|
|
unsigned int texel_count = pi.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
vfloat4 average = partition_averages[partition];
|
||
|
|
pm[partition].avg = average;
|
||
|
|
|
||
|
|
vfloat4 sum_xp = vfloat4::zero();
|
||
|
|
vfloat4 sum_yp = vfloat4::zero();
|
||
|
|
vfloat4 sum_zp = vfloat4::zero();
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < texel_count; i++)
|
||
|
|
{
|
||
|
|
unsigned int iwt = texel_indexes[i];
|
||
|
|
|
||
|
|
vfloat4 texel_datum = blk.texel3(iwt);
|
||
|
|
texel_datum = texel_datum - average;
|
||
|
|
|
||
|
|
vfloat4 zero = vfloat4::zero();
|
||
|
|
|
||
|
|
vmask4 tdm0 = texel_datum.swz<0,0,0,0>() > zero;
|
||
|
|
sum_xp += select(zero, texel_datum, tdm0);
|
||
|
|
|
||
|
|
vmask4 tdm1 = texel_datum.swz<1,1,1,1>() > zero;
|
||
|
|
sum_yp += select(zero, texel_datum, tdm1);
|
||
|
|
|
||
|
|
vmask4 tdm2 = texel_datum.swz<2,2,2,2>() > zero;
|
||
|
|
sum_zp += select(zero, texel_datum, tdm2);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 prod_xp = dot(sum_xp, sum_xp);
|
||
|
|
vfloat4 prod_yp = dot(sum_yp, sum_yp);
|
||
|
|
vfloat4 prod_zp = dot(sum_zp, sum_zp);
|
||
|
|
|
||
|
|
vfloat4 best_vector = sum_xp;
|
||
|
|
vfloat4 best_sum = prod_xp;
|
||
|
|
|
||
|
|
vmask4 mask = prod_yp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_yp, mask);
|
||
|
|
best_sum = select(best_sum, prod_yp, mask);
|
||
|
|
|
||
|
|
mask = prod_zp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_zp, mask);
|
||
|
|
|
||
|
|
pm[partition].dir = best_vector;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_avgs_and_dirs_2_comp(
|
||
|
|
const partition_info& pt,
|
||
|
|
const image_block& blk,
|
||
|
|
unsigned int component1,
|
||
|
|
unsigned int component2,
|
||
|
|
partition_metrics pm[BLOCK_MAX_PARTITIONS]
|
||
|
|
) {
|
||
|
|
vfloat4 average;
|
||
|
|
|
||
|
|
const float* data_vr = nullptr;
|
||
|
|
const float* data_vg = nullptr;
|
||
|
|
|
||
|
|
if (component1 == 0 && component2 == 1)
|
||
|
|
{
|
||
|
|
average = blk.data_mean.swz<0, 1>();
|
||
|
|
|
||
|
|
data_vr = blk.data_r;
|
||
|
|
data_vg = blk.data_g;
|
||
|
|
}
|
||
|
|
else if (component1 == 0 && component2 == 2)
|
||
|
|
{
|
||
|
|
average = blk.data_mean.swz<0, 2>();
|
||
|
|
|
||
|
|
data_vr = blk.data_r;
|
||
|
|
data_vg = blk.data_b;
|
||
|
|
}
|
||
|
|
else // (component1 == 1 && component2 == 2)
|
||
|
|
{
|
||
|
|
assert(component1 == 1 && component2 == 2);
|
||
|
|
|
||
|
|
average = blk.data_mean.swz<1, 2>();
|
||
|
|
|
||
|
|
data_vr = blk.data_g;
|
||
|
|
data_vg = blk.data_b;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int partition_count = pt.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
for (unsigned int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
const uint8_t *texel_indexes = pt.texels_of_partition[partition];
|
||
|
|
unsigned int texel_count = pt.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
// Only compute a partition mean if more than one partition
|
||
|
|
if (partition_count > 1)
|
||
|
|
{
|
||
|
|
average = vfloat4::zero();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i++)
|
||
|
|
{
|
||
|
|
unsigned int iwt = texel_indexes[i];
|
||
|
|
average += vfloat2(data_vr[iwt], data_vg[iwt]);
|
||
|
|
}
|
||
|
|
|
||
|
|
average = average / static_cast<float>(texel_count);
|
||
|
|
}
|
||
|
|
|
||
|
|
pm[partition].avg = average;
|
||
|
|
|
||
|
|
vfloat4 sum_xp = vfloat4::zero();
|
||
|
|
vfloat4 sum_yp = vfloat4::zero();
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < texel_count; i++)
|
||
|
|
{
|
||
|
|
unsigned int iwt = texel_indexes[i];
|
||
|
|
vfloat4 texel_datum = vfloat2(data_vr[iwt], data_vg[iwt]);
|
||
|
|
texel_datum = texel_datum - average;
|
||
|
|
|
||
|
|
vfloat4 zero = vfloat4::zero();
|
||
|
|
|
||
|
|
vmask4 tdm0 = texel_datum.swz<0,0,0,0>() > zero;
|
||
|
|
sum_xp += select(zero, texel_datum, tdm0);
|
||
|
|
|
||
|
|
vmask4 tdm1 = texel_datum.swz<1,1,1,1>() > zero;
|
||
|
|
sum_yp += select(zero, texel_datum, tdm1);
|
||
|
|
}
|
||
|
|
|
||
|
|
vfloat4 prod_xp = dot(sum_xp, sum_xp);
|
||
|
|
vfloat4 prod_yp = dot(sum_yp, sum_yp);
|
||
|
|
|
||
|
|
vfloat4 best_vector = sum_xp;
|
||
|
|
vfloat4 best_sum = prod_xp;
|
||
|
|
|
||
|
|
vmask4 mask = prod_yp > best_sum;
|
||
|
|
best_vector = select(best_vector, sum_yp, mask);
|
||
|
|
|
||
|
|
pm[partition].dir = best_vector;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_error_squared_rgba(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
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
|
||
|
|
) {
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
vfloatacc uncor_errorsumv = vfloatacc::zero();
|
||
|
|
vfloatacc samec_errorsumv = vfloatacc::zero();
|
||
|
|
|
||
|
|
for (unsigned int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
const uint8_t *texel_indexes = pi.texels_of_partition[partition];
|
||
|
|
|
||
|
|
float uncor_loparam = 1e10f;
|
||
|
|
float uncor_hiparam = -1e10f;
|
||
|
|
|
||
|
|
float samec_loparam = 1e10f;
|
||
|
|
float samec_hiparam = -1e10f;
|
||
|
|
|
||
|
|
processed_line4 l_uncor = uncor_plines[partition];
|
||
|
|
processed_line4 l_samec = samec_plines[partition];
|
||
|
|
|
||
|
|
unsigned int texel_count = pi.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
// Vectorize some useful scalar inputs
|
||
|
|
vfloat l_uncor_bs0(l_uncor.bs.lane<0>());
|
||
|
|
vfloat l_uncor_bs1(l_uncor.bs.lane<1>());
|
||
|
|
vfloat l_uncor_bs2(l_uncor.bs.lane<2>());
|
||
|
|
vfloat l_uncor_bs3(l_uncor.bs.lane<3>());
|
||
|
|
|
||
|
|
vfloat l_uncor_amod0(l_uncor.amod.lane<0>());
|
||
|
|
vfloat l_uncor_amod1(l_uncor.amod.lane<1>());
|
||
|
|
vfloat l_uncor_amod2(l_uncor.amod.lane<2>());
|
||
|
|
vfloat l_uncor_amod3(l_uncor.amod.lane<3>());
|
||
|
|
|
||
|
|
vfloat l_samec_bs0(l_samec.bs.lane<0>());
|
||
|
|
vfloat l_samec_bs1(l_samec.bs.lane<1>());
|
||
|
|
vfloat l_samec_bs2(l_samec.bs.lane<2>());
|
||
|
|
vfloat l_samec_bs3(l_samec.bs.lane<3>());
|
||
|
|
|
||
|
|
assert(all(l_samec.amod == vfloat4(0.0f)));
|
||
|
|
|
||
|
|
vfloat uncor_loparamv(1e10f);
|
||
|
|
vfloat uncor_hiparamv(-1e10f);
|
||
|
|
|
||
|
|
vfloat samec_loparamv(1e10f);
|
||
|
|
vfloat samec_hiparamv(-1e10f);
|
||
|
|
|
||
|
|
vfloat ew_r(blk.channel_weight.lane<0>());
|
||
|
|
vfloat ew_g(blk.channel_weight.lane<1>());
|
||
|
|
vfloat ew_b(blk.channel_weight.lane<2>());
|
||
|
|
vfloat ew_a(blk.channel_weight.lane<3>());
|
||
|
|
|
||
|
|
// This implementation over-shoots, but this is safe as we initialize the texel_indexes
|
||
|
|
// array to extend the last value. This means min/max are not impacted, but we need to mask
|
||
|
|
// out the dummy values when we compute the line weighting.
|
||
|
|
vint lane_ids = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vmask mask = lane_ids < vint(texel_count);
|
||
|
|
vint texel_idxs(texel_indexes + i);
|
||
|
|
|
||
|
|
vfloat data_r = gatherf(blk.data_r, texel_idxs);
|
||
|
|
vfloat data_g = gatherf(blk.data_g, texel_idxs);
|
||
|
|
vfloat data_b = gatherf(blk.data_b, texel_idxs);
|
||
|
|
vfloat data_a = gatherf(blk.data_a, texel_idxs);
|
||
|
|
|
||
|
|
vfloat uncor_param = (data_r * l_uncor_bs0)
|
||
|
|
+ (data_g * l_uncor_bs1)
|
||
|
|
+ (data_b * l_uncor_bs2)
|
||
|
|
+ (data_a * l_uncor_bs3);
|
||
|
|
|
||
|
|
uncor_loparamv = min(uncor_param, uncor_loparamv);
|
||
|
|
uncor_hiparamv = max(uncor_param, uncor_hiparamv);
|
||
|
|
|
||
|
|
vfloat uncor_dist0 = (l_uncor_amod0 - data_r)
|
||
|
|
+ (uncor_param * l_uncor_bs0);
|
||
|
|
vfloat uncor_dist1 = (l_uncor_amod1 - data_g)
|
||
|
|
+ (uncor_param * l_uncor_bs1);
|
||
|
|
vfloat uncor_dist2 = (l_uncor_amod2 - data_b)
|
||
|
|
+ (uncor_param * l_uncor_bs2);
|
||
|
|
vfloat uncor_dist3 = (l_uncor_amod3 - data_a)
|
||
|
|
+ (uncor_param * l_uncor_bs3);
|
||
|
|
|
||
|
|
vfloat uncor_err = (ew_r * uncor_dist0 * uncor_dist0)
|
||
|
|
+ (ew_g * uncor_dist1 * uncor_dist1)
|
||
|
|
+ (ew_b * uncor_dist2 * uncor_dist2)
|
||
|
|
+ (ew_a * uncor_dist3 * uncor_dist3);
|
||
|
|
|
||
|
|
haccumulate(uncor_errorsumv, uncor_err, mask);
|
||
|
|
|
||
|
|
// Process samechroma data
|
||
|
|
vfloat samec_param = (data_r * l_samec_bs0)
|
||
|
|
+ (data_g * l_samec_bs1)
|
||
|
|
+ (data_b * l_samec_bs2)
|
||
|
|
+ (data_a * l_samec_bs3);
|
||
|
|
|
||
|
|
samec_loparamv = min(samec_param, samec_loparamv);
|
||
|
|
samec_hiparamv = max(samec_param, samec_hiparamv);
|
||
|
|
|
||
|
|
vfloat samec_dist0 = samec_param * l_samec_bs0 - data_r;
|
||
|
|
vfloat samec_dist1 = samec_param * l_samec_bs1 - data_g;
|
||
|
|
vfloat samec_dist2 = samec_param * l_samec_bs2 - data_b;
|
||
|
|
vfloat samec_dist3 = samec_param * l_samec_bs3 - data_a;
|
||
|
|
|
||
|
|
vfloat samec_err = (ew_r * samec_dist0 * samec_dist0)
|
||
|
|
+ (ew_g * samec_dist1 * samec_dist1)
|
||
|
|
+ (ew_b * samec_dist2 * samec_dist2)
|
||
|
|
+ (ew_a * samec_dist3 * samec_dist3);
|
||
|
|
|
||
|
|
haccumulate(samec_errorsumv, samec_err, mask);
|
||
|
|
|
||
|
|
lane_ids += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
}
|
||
|
|
|
||
|
|
uncor_loparam = hmin_s(uncor_loparamv);
|
||
|
|
uncor_hiparam = hmax_s(uncor_hiparamv);
|
||
|
|
|
||
|
|
samec_loparam = hmin_s(samec_loparamv);
|
||
|
|
samec_hiparam = hmax_s(samec_hiparamv);
|
||
|
|
|
||
|
|
float uncor_linelen = uncor_hiparam - uncor_loparam;
|
||
|
|
float samec_linelen = samec_hiparam - samec_loparam;
|
||
|
|
|
||
|
|
// Turn very small numbers and NaNs into a small number
|
||
|
|
uncor_lengths[partition] = astc::max(uncor_linelen, 1e-7f);
|
||
|
|
samec_lengths[partition] = astc::max(samec_linelen, 1e-7f);
|
||
|
|
}
|
||
|
|
|
||
|
|
uncor_error = hadd_s(uncor_errorsumv);
|
||
|
|
samec_error = hadd_s(samec_errorsumv);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* See header for documentation. */
|
||
|
|
void compute_error_squared_rgb(
|
||
|
|
const partition_info& pi,
|
||
|
|
const image_block& blk,
|
||
|
|
partition_lines3 plines[BLOCK_MAX_PARTITIONS],
|
||
|
|
float& uncor_error,
|
||
|
|
float& samec_error
|
||
|
|
) {
|
||
|
|
unsigned int partition_count = pi.partition_count;
|
||
|
|
promise(partition_count > 0);
|
||
|
|
|
||
|
|
vfloatacc uncor_errorsumv = vfloatacc::zero();
|
||
|
|
vfloatacc samec_errorsumv = vfloatacc::zero();
|
||
|
|
|
||
|
|
for (unsigned int partition = 0; partition < partition_count; partition++)
|
||
|
|
{
|
||
|
|
partition_lines3& pl = plines[partition];
|
||
|
|
const uint8_t *texel_indexes = pi.texels_of_partition[partition];
|
||
|
|
unsigned int texel_count = pi.partition_texel_count[partition];
|
||
|
|
promise(texel_count > 0);
|
||
|
|
|
||
|
|
float uncor_loparam = 1e10f;
|
||
|
|
float uncor_hiparam = -1e10f;
|
||
|
|
|
||
|
|
float samec_loparam = 1e10f;
|
||
|
|
float samec_hiparam = -1e10f;
|
||
|
|
|
||
|
|
processed_line3 l_uncor = pl.uncor_pline;
|
||
|
|
processed_line3 l_samec = pl.samec_pline;
|
||
|
|
|
||
|
|
// This implementation is an example vectorization of this function.
|
||
|
|
// It works for - the codec is a 2-4% faster than not vectorizing - but
|
||
|
|
// the benefit is limited by the use of gathers and register pressure
|
||
|
|
|
||
|
|
// Vectorize some useful scalar inputs
|
||
|
|
vfloat l_uncor_bs0(l_uncor.bs.lane<0>());
|
||
|
|
vfloat l_uncor_bs1(l_uncor.bs.lane<1>());
|
||
|
|
vfloat l_uncor_bs2(l_uncor.bs.lane<2>());
|
||
|
|
|
||
|
|
vfloat l_uncor_amod0(l_uncor.amod.lane<0>());
|
||
|
|
vfloat l_uncor_amod1(l_uncor.amod.lane<1>());
|
||
|
|
vfloat l_uncor_amod2(l_uncor.amod.lane<2>());
|
||
|
|
|
||
|
|
vfloat l_samec_bs0(l_samec.bs.lane<0>());
|
||
|
|
vfloat l_samec_bs1(l_samec.bs.lane<1>());
|
||
|
|
vfloat l_samec_bs2(l_samec.bs.lane<2>());
|
||
|
|
|
||
|
|
assert(all(l_samec.amod == vfloat4(0.0f)));
|
||
|
|
|
||
|
|
vfloat uncor_loparamv(1e10f);
|
||
|
|
vfloat uncor_hiparamv(-1e10f);
|
||
|
|
|
||
|
|
vfloat samec_loparamv(1e10f);
|
||
|
|
vfloat samec_hiparamv(-1e10f);
|
||
|
|
|
||
|
|
vfloat ew_r(blk.channel_weight.lane<0>());
|
||
|
|
vfloat ew_g(blk.channel_weight.lane<1>());
|
||
|
|
vfloat ew_b(blk.channel_weight.lane<2>());
|
||
|
|
|
||
|
|
// This implementation over-shoots, but this is safe as we initialize the weights array
|
||
|
|
// to extend the last value. This means min/max are not impacted, but we need to mask
|
||
|
|
// out the dummy values when we compute the line weighting.
|
||
|
|
vint lane_ids = vint::lane_id();
|
||
|
|
for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH)
|
||
|
|
{
|
||
|
|
vmask mask = lane_ids < vint(texel_count);
|
||
|
|
vint texel_idxs(texel_indexes + i);
|
||
|
|
|
||
|
|
vfloat data_r = gatherf(blk.data_r, texel_idxs);
|
||
|
|
vfloat data_g = gatherf(blk.data_g, texel_idxs);
|
||
|
|
vfloat data_b = gatherf(blk.data_b, texel_idxs);
|
||
|
|
|
||
|
|
vfloat uncor_param = (data_r * l_uncor_bs0)
|
||
|
|
+ (data_g * l_uncor_bs1)
|
||
|
|
+ (data_b * l_uncor_bs2);
|
||
|
|
|
||
|
|
uncor_loparamv = min(uncor_param, uncor_loparamv);
|
||
|
|
uncor_hiparamv = max(uncor_param, uncor_hiparamv);
|
||
|
|
|
||
|
|
vfloat uncor_dist0 = (l_uncor_amod0 - data_r)
|
||
|
|
+ (uncor_param * l_uncor_bs0);
|
||
|
|
vfloat uncor_dist1 = (l_uncor_amod1 - data_g)
|
||
|
|
+ (uncor_param * l_uncor_bs1);
|
||
|
|
vfloat uncor_dist2 = (l_uncor_amod2 - data_b)
|
||
|
|
+ (uncor_param * l_uncor_bs2);
|
||
|
|
|
||
|
|
vfloat uncor_err = (ew_r * uncor_dist0 * uncor_dist0)
|
||
|
|
+ (ew_g * uncor_dist1 * uncor_dist1)
|
||
|
|
+ (ew_b * uncor_dist2 * uncor_dist2);
|
||
|
|
|
||
|
|
haccumulate(uncor_errorsumv, uncor_err, mask);
|
||
|
|
|
||
|
|
// Process samechroma data
|
||
|
|
vfloat samec_param = (data_r * l_samec_bs0)
|
||
|
|
+ (data_g * l_samec_bs1)
|
||
|
|
+ (data_b * l_samec_bs2);
|
||
|
|
|
||
|
|
samec_loparamv = min(samec_param, samec_loparamv);
|
||
|
|
samec_hiparamv = max(samec_param, samec_hiparamv);
|
||
|
|
|
||
|
|
vfloat samec_dist0 = samec_param * l_samec_bs0 - data_r;
|
||
|
|
vfloat samec_dist1 = samec_param * l_samec_bs1 - data_g;
|
||
|
|
vfloat samec_dist2 = samec_param * l_samec_bs2 - data_b;
|
||
|
|
|
||
|
|
vfloat samec_err = (ew_r * samec_dist0 * samec_dist0)
|
||
|
|
+ (ew_g * samec_dist1 * samec_dist1)
|
||
|
|
+ (ew_b * samec_dist2 * samec_dist2);
|
||
|
|
|
||
|
|
haccumulate(samec_errorsumv, samec_err, mask);
|
||
|
|
|
||
|
|
lane_ids += vint(ASTCENC_SIMD_WIDTH);
|
||
|
|
}
|
||
|
|
|
||
|
|
uncor_loparam = hmin_s(uncor_loparamv);
|
||
|
|
uncor_hiparam = hmax_s(uncor_hiparamv);
|
||
|
|
|
||
|
|
samec_loparam = hmin_s(samec_loparamv);
|
||
|
|
samec_hiparam = hmax_s(samec_hiparamv);
|
||
|
|
|
||
|
|
float uncor_linelen = uncor_hiparam - uncor_loparam;
|
||
|
|
float samec_linelen = samec_hiparam - samec_loparam;
|
||
|
|
|
||
|
|
// Turn very small numbers and NaNs into a small number
|
||
|
|
pl.uncor_line_len = astc::max(uncor_linelen, 1e-7f);
|
||
|
|
pl.samec_line_len = astc::max(samec_linelen, 1e-7f);
|
||
|
|
}
|
||
|
|
|
||
|
|
uncor_error = hadd_s(uncor_errorsumv);
|
||
|
|
samec_error = hadd_s(samec_errorsumv);
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|