| // 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. |
| // ---------------------------------------------------------------------------- |
| |
| #if !defined(ASTCENC_DECOMPRESS_ONLY) |
| |
| /** |
| * @brief Functions for computing color endpoints and texel weights. |
| */ |
| |
| #include <cassert> |
| |
| #include "astcenc_internal.h" |
| #include "astcenc_vecmathlib.h" |
| |
| /** |
| * @brief Compute the infilled weight for N texel indices in a decimated grid. |
| * |
| * @param di The weight grid decimation to use. |
| * @param weights The decimated weight values to use. |
| * @param index The first texel index to interpolate. |
| * |
| * @return The interpolated weight for the given set of SIMD_WIDTH texels. |
| */ |
| static 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 infilled weight for N texel indices in a decimated grid. |
| * |
| * This is specialized version which computes only two weights per texel for |
| * encodings that are only decimated in a single axis. |
| * |
| * @param di The weight grid decimation to use. |
| * @param weights The decimated weight values to use. |
| * @param index The first texel index to interpolate. |
| * |
| * @return The interpolated weight for the given set of SIMD_WIDTH texels. |
| */ |
| static vfloat bilinear_infill_vla_2( |
| 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); |
| |
| // Load the bilinear filter weights from the decimated grid |
| vfloat weight_val0 = gatherf(weights, weight_idx0); |
| vfloat weight_val1 = gatherf(weights, weight_idx1); |
| |
| // 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); |
| |
| // Compute the bilinear interpolation to generate the per-texel weight |
| return (weight_val0 * tex_weight_float0 + weight_val1 * tex_weight_float1); |
| } |
| |
| /** |
| * @brief Compute the ideal endpoints and weights for 1 color component. |
| * |
| * @param blk The image block color data to compress. |
| * @param pi The partition info for the current trial. |
| * @param[out] ei The computed ideal endpoints and weights. |
| * @param component The color component to compute. |
| */ |
| static void compute_ideal_colors_and_weights_1_comp( |
| const image_block& blk, |
| const partition_info& pi, |
| endpoints_and_weights& ei, |
| unsigned int component |
| ) { |
| unsigned int partition_count = pi.partition_count; |
| ei.ep.partition_count = partition_count; |
| promise(partition_count > 0); |
| |
| unsigned int texel_count = blk.texel_count; |
| promise(texel_count > 0); |
| |
| float error_weight; |
| const float* data_vr = nullptr; |
| |
| assert(component < BLOCK_MAX_COMPONENTS); |
| switch (component) |
| { |
| case 0: |
| error_weight = blk.channel_weight.lane<0>(); |
| data_vr = blk.data_r; |
| break; |
| case 1: |
| error_weight = blk.channel_weight.lane<1>(); |
| data_vr = blk.data_g; |
| break; |
| case 2: |
| error_weight = blk.channel_weight.lane<2>(); |
| data_vr = blk.data_b; |
| break; |
| default: |
| assert(component == 3); |
| error_weight = blk.channel_weight.lane<3>(); |
| data_vr = blk.data_a; |
| break; |
| } |
| |
| vmask4 sep_mask = vint4::lane_id() == vint4(component); |
| bool is_constant_wes { true }; |
| float partition0_len_sq { 0.0f }; |
| |
| for (unsigned int i = 0; i < partition_count; i++) |
| { |
| float lowvalue { 1e10f }; |
| float highvalue { -1e10f }; |
| |
| unsigned int partition_texel_count = pi.partition_texel_count[i]; |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| float value = data_vr[tix]; |
| lowvalue = astc::min(value, lowvalue); |
| highvalue = astc::max(value, highvalue); |
| } |
| |
| if (highvalue <= lowvalue) |
| { |
| lowvalue = 0.0f; |
| highvalue = 1e-7f; |
| } |
| |
| float length = highvalue - lowvalue; |
| float length_squared = length * length; |
| float scale = 1.0f / length; |
| |
| if (i == 0) |
| { |
| partition0_len_sq = length_squared; |
| } |
| else |
| { |
| is_constant_wes = is_constant_wes && length_squared == partition0_len_sq; |
| } |
| |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| float value = (data_vr[tix] - lowvalue) * scale; |
| value = astc::clamp1f(value); |
| |
| ei.weights[tix] = value; |
| ei.weight_error_scale[tix] = length_squared * error_weight; |
| assert(!astc::isnan(ei.weight_error_scale[tix])); |
| } |
| |
| ei.ep.endpt0[i] = select(blk.data_min, vfloat4(lowvalue), sep_mask); |
| ei.ep.endpt1[i] = select(blk.data_max, vfloat4(highvalue), sep_mask); |
| } |
| |
| // Zero initialize any SIMD over-fetch |
| unsigned int texel_count_simd = round_up_to_simd_multiple_vla(texel_count); |
| for (unsigned int i = texel_count; i < texel_count_simd; i++) |
| { |
| ei.weights[i] = 0.0f; |
| ei.weight_error_scale[i] = 0.0f; |
| } |
| |
| ei.is_constant_weight_error_scale = is_constant_wes; |
| } |
| |
| /** |
| * @brief Compute the ideal endpoints and weights for 2 color components. |
| * |
| * @param blk The image block color data to compress. |
| * @param pi The partition info for the current trial. |
| * @param[out] ei The computed ideal endpoints and weights. |
| * @param component1 The first color component to compute. |
| * @param component2 The second color component to compute. |
| */ |
| static void compute_ideal_colors_and_weights_2_comp( |
| const image_block& blk, |
| const partition_info& pi, |
| endpoints_and_weights& ei, |
| int component1, |
| int component2 |
| ) { |
| unsigned int partition_count = pi.partition_count; |
| ei.ep.partition_count = partition_count; |
| promise(partition_count > 0); |
| |
| unsigned int texel_count = blk.texel_count; |
| promise(texel_count > 0); |
| |
| partition_metrics pms[BLOCK_MAX_PARTITIONS]; |
| |
| float error_weight; |
| const float* data_vr = nullptr; |
| const float* data_vg = nullptr; |
| |
| if (component1 == 0 && component2 == 1) |
| { |
| error_weight = hadd_s(blk.channel_weight.swz<0, 1>()) / 2.0f; |
| |
| data_vr = blk.data_r; |
| data_vg = blk.data_g; |
| } |
| else if (component1 == 0 && component2 == 2) |
| { |
| error_weight = hadd_s(blk.channel_weight.swz<0, 2>()) / 2.0f; |
| |
| data_vr = blk.data_r; |
| data_vg = blk.data_b; |
| } |
| else // (component1 == 1 && component2 == 2) |
| { |
| assert(component1 == 1 && component2 == 2); |
| |
| error_weight = hadd_s(blk.channel_weight.swz<1, 2>()) / 2.0f; |
| |
| data_vr = blk.data_g; |
| data_vg = blk.data_b; |
| } |
| |
| compute_avgs_and_dirs_2_comp(pi, blk, component1, component2, pms); |
| |
| bool is_constant_wes { true }; |
| float partition0_len_sq { 0.0f }; |
| |
| vmask4 comp1_mask = vint4::lane_id() == vint4(component1); |
| vmask4 comp2_mask = vint4::lane_id() == vint4(component2); |
| |
| for (unsigned int i = 0; i < partition_count; i++) |
| { |
| vfloat4 dir = pms[i].dir; |
| if (hadd_s(dir) < 0.0f) |
| { |
| dir = vfloat4::zero() - dir; |
| } |
| |
| line2 line { pms[i].avg, normalize_safe(dir, unit2()) }; |
| float lowparam { 1e10f }; |
| float highparam { -1e10f }; |
| |
| unsigned int partition_texel_count = pi.partition_texel_count[i]; |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| vfloat4 point = vfloat2(data_vr[tix], data_vg[tix]); |
| float param = dot_s(point - line.a, line.b); |
| ei.weights[tix] = param; |
| |
| lowparam = astc::min(param, lowparam); |
| highparam = astc::max(param, highparam); |
| } |
| |
| // It is possible for a uniform-color partition to produce length=0; |
| // this causes NaN issues so set to small value to avoid this problem |
| if (highparam <= lowparam) |
| { |
| lowparam = 0.0f; |
| highparam = 1e-7f; |
| } |
| |
| float length = highparam - lowparam; |
| float length_squared = length * length; |
| float scale = 1.0f / length; |
| |
| if (i == 0) |
| { |
| partition0_len_sq = length_squared; |
| } |
| else |
| { |
| is_constant_wes = is_constant_wes && length_squared == partition0_len_sq; |
| } |
| |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| float idx = (ei.weights[tix] - lowparam) * scale; |
| idx = astc::clamp1f(idx); |
| |
| ei.weights[tix] = idx; |
| ei.weight_error_scale[tix] = length_squared * error_weight; |
| assert(!astc::isnan(ei.weight_error_scale[tix])); |
| } |
| |
| vfloat4 lowvalue = line.a + line.b * lowparam; |
| vfloat4 highvalue = line.a + line.b * highparam; |
| |
| vfloat4 ep0 = select(blk.data_min, vfloat4(lowvalue.lane<0>()), comp1_mask); |
| vfloat4 ep1 = select(blk.data_max, vfloat4(highvalue.lane<0>()), comp1_mask); |
| |
| ei.ep.endpt0[i] = select(ep0, vfloat4(lowvalue.lane<1>()), comp2_mask); |
| ei.ep.endpt1[i] = select(ep1, vfloat4(highvalue.lane<1>()), comp2_mask); |
| } |
| |
| // Zero initialize any SIMD over-fetch |
| unsigned int texel_count_simd = round_up_to_simd_multiple_vla(texel_count); |
| for (unsigned int i = texel_count; i < texel_count_simd; i++) |
| { |
| ei.weights[i] = 0.0f; |
| ei.weight_error_scale[i] = 0.0f; |
| } |
| |
| ei.is_constant_weight_error_scale = is_constant_wes; |
| } |
| |
| /** |
| * @brief Compute the ideal endpoints and weights for 3 color components. |
| * |
| * @param blk The image block color data to compress. |
| * @param pi The partition info for the current trial. |
| * @param[out] ei The computed ideal endpoints and weights. |
| * @param omitted_component The color component excluded from the calculation. |
| */ |
| static void compute_ideal_colors_and_weights_3_comp( |
| const image_block& blk, |
| const partition_info& pi, |
| endpoints_and_weights& ei, |
| unsigned int omitted_component |
| ) { |
| unsigned int partition_count = pi.partition_count; |
| ei.ep.partition_count = partition_count; |
| promise(partition_count > 0); |
| |
| unsigned int texel_count = blk.texel_count; |
| promise(texel_count > 0); |
| |
| partition_metrics pms[BLOCK_MAX_PARTITIONS]; |
| |
| float error_weight; |
| const float* data_vr = nullptr; |
| const float* data_vg = nullptr; |
| const float* data_vb = nullptr; |
| if (omitted_component == 0) |
| { |
| error_weight = hadd_s(blk.channel_weight.swz<0, 1, 2>()); |
| data_vr = blk.data_g; |
| data_vg = blk.data_b; |
| data_vb = blk.data_a; |
| } |
| else if (omitted_component == 1) |
| { |
| error_weight = hadd_s(blk.channel_weight.swz<0, 2, 3>()); |
| data_vr = blk.data_r; |
| data_vg = blk.data_b; |
| data_vb = blk.data_a; |
| } |
| else if (omitted_component == 2) |
| { |
| error_weight = hadd_s(blk.channel_weight.swz<0, 1, 3>()); |
| data_vr = blk.data_r; |
| data_vg = blk.data_g; |
| data_vb = blk.data_a; |
| } |
| else |
| { |
| assert(omitted_component == 3); |
| |
| error_weight = hadd_s(blk.channel_weight.swz<0, 1, 2>()); |
| data_vr = blk.data_r; |
| data_vg = blk.data_g; |
| data_vb = blk.data_b; |
| } |
| |
| error_weight = error_weight * (1.0f / 3.0f); |
| |
| if (omitted_component == 3) |
| { |
| compute_avgs_and_dirs_3_comp_rgb(pi, blk, pms); |
| } |
| else |
| { |
| compute_avgs_and_dirs_3_comp(pi, blk, omitted_component, pms); |
| } |
| |
| bool is_constant_wes { true }; |
| float partition0_len_sq { 0.0f }; |
| |
| for (unsigned int i = 0; i < partition_count; i++) |
| { |
| vfloat4 dir = pms[i].dir; |
| if (hadd_rgb_s(dir) < 0.0f) |
| { |
| dir = vfloat4::zero() - dir; |
| } |
| |
| line3 line { pms[i].avg, normalize_safe(dir, unit3()) }; |
| float lowparam { 1e10f }; |
| float highparam { -1e10f }; |
| |
| unsigned int partition_texel_count = pi.partition_texel_count[i]; |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| vfloat4 point = vfloat3(data_vr[tix], data_vg[tix], data_vb[tix]); |
| float param = dot3_s(point - line.a, line.b); |
| ei.weights[tix] = param; |
| |
| lowparam = astc::min(param, lowparam); |
| highparam = astc::max(param, highparam); |
| } |
| |
| // It is possible for a uniform-color partition to produce length=0; |
| // this causes NaN issues so set to small value to avoid this problem |
| if (highparam <= lowparam) |
| { |
| lowparam = 0.0f; |
| highparam = 1e-7f; |
| } |
| |
| float length = highparam - lowparam; |
| float length_squared = length * length; |
| float scale = 1.0f / length; |
| |
| if (i == 0) |
| { |
| partition0_len_sq = length_squared; |
| } |
| else |
| { |
| is_constant_wes = is_constant_wes && length_squared == partition0_len_sq; |
| } |
| |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| float idx = (ei.weights[tix] - lowparam) * scale; |
| idx = astc::clamp1f(idx); |
| |
| ei.weights[tix] = idx; |
| ei.weight_error_scale[tix] = length_squared * error_weight; |
| assert(!astc::isnan(ei.weight_error_scale[tix])); |
| } |
| |
| vfloat4 ep0 = line.a + line.b * lowparam; |
| vfloat4 ep1 = line.a + line.b * highparam; |
| |
| vfloat4 bmin = blk.data_min; |
| vfloat4 bmax = blk.data_max; |
| |
| assert(omitted_component < BLOCK_MAX_COMPONENTS); |
| switch (omitted_component) |
| { |
| case 0: |
| ei.ep.endpt0[i] = vfloat4(bmin.lane<0>(), ep0.lane<0>(), ep0.lane<1>(), ep0.lane<2>()); |
| ei.ep.endpt1[i] = vfloat4(bmax.lane<0>(), ep1.lane<0>(), ep1.lane<1>(), ep1.lane<2>()); |
| break; |
| case 1: |
| ei.ep.endpt0[i] = vfloat4(ep0.lane<0>(), bmin.lane<1>(), ep0.lane<1>(), ep0.lane<2>()); |
| ei.ep.endpt1[i] = vfloat4(ep1.lane<0>(), bmax.lane<1>(), ep1.lane<1>(), ep1.lane<2>()); |
| break; |
| case 2: |
| ei.ep.endpt0[i] = vfloat4(ep0.lane<0>(), ep0.lane<1>(), bmin.lane<2>(), ep0.lane<2>()); |
| ei.ep.endpt1[i] = vfloat4(ep1.lane<0>(), ep1.lane<1>(), bmax.lane<2>(), ep1.lane<2>()); |
| break; |
| default: |
| ei.ep.endpt0[i] = vfloat4(ep0.lane<0>(), ep0.lane<1>(), ep0.lane<2>(), bmin.lane<3>()); |
| ei.ep.endpt1[i] = vfloat4(ep1.lane<0>(), ep1.lane<1>(), ep1.lane<2>(), bmax.lane<3>()); |
| break; |
| } |
| } |
| |
| // Zero initialize any SIMD over-fetch |
| unsigned int texel_count_simd = round_up_to_simd_multiple_vla(texel_count); |
| for (unsigned int i = texel_count; i < texel_count_simd; i++) |
| { |
| ei.weights[i] = 0.0f; |
| ei.weight_error_scale[i] = 0.0f; |
| } |
| |
| ei.is_constant_weight_error_scale = is_constant_wes; |
| } |
| |
| /** |
| * @brief Compute the ideal endpoints and weights for 4 color components. |
| * |
| * @param blk The image block color data to compress. |
| * @param pi The partition info for the current trial. |
| * @param[out] ei The computed ideal endpoints and weights. |
| */ |
| static void compute_ideal_colors_and_weights_4_comp( |
| const image_block& blk, |
| const partition_info& pi, |
| endpoints_and_weights& ei |
| ) { |
| const float error_weight = hadd_s(blk.channel_weight) / 4.0f; |
| |
| unsigned int partition_count = pi.partition_count; |
| |
| unsigned int texel_count = blk.texel_count; |
| promise(texel_count > 0); |
| promise(partition_count > 0); |
| |
| partition_metrics pms[BLOCK_MAX_PARTITIONS]; |
| |
| compute_avgs_and_dirs_4_comp(pi, blk, pms); |
| |
| bool is_constant_wes { true }; |
| float partition0_len_sq { 0.0f }; |
| |
| for (unsigned int i = 0; i < partition_count; i++) |
| { |
| vfloat4 dir = pms[i].dir; |
| if (hadd_rgb_s(dir) < 0.0f) |
| { |
| dir = vfloat4::zero() - dir; |
| } |
| |
| line4 line { pms[i].avg, normalize_safe(dir, unit4()) }; |
| float lowparam { 1e10f }; |
| float highparam { -1e10f }; |
| |
| unsigned int partition_texel_count = pi.partition_texel_count[i]; |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| vfloat4 point = blk.texel(tix); |
| float param = dot_s(point - line.a, line.b); |
| ei.weights[tix] = param; |
| |
| lowparam = astc::min(param, lowparam); |
| highparam = astc::max(param, highparam); |
| } |
| |
| // It is possible for a uniform-color partition to produce length=0; |
| // this causes NaN issues so set to small value to avoid this problem |
| if (highparam <= lowparam) |
| { |
| lowparam = 0.0f; |
| highparam = 1e-7f; |
| } |
| |
| float length = highparam - lowparam; |
| float length_squared = length * length; |
| float scale = 1.0f / length; |
| |
| if (i == 0) |
| { |
| partition0_len_sq = length_squared; |
| } |
| else |
| { |
| is_constant_wes = is_constant_wes && length_squared == partition0_len_sq; |
| } |
| |
| ei.ep.endpt0[i] = line.a + line.b * lowparam; |
| ei.ep.endpt1[i] = line.a + line.b * highparam; |
| |
| for (unsigned int j = 0; j < partition_texel_count; j++) |
| { |
| unsigned int tix = pi.texels_of_partition[i][j]; |
| float idx = (ei.weights[tix] - lowparam) * scale; |
| idx = astc::clamp1f(idx); |
| |
| ei.weights[tix] = idx; |
| ei.weight_error_scale[tix] = length_squared * error_weight; |
| assert(!astc::isnan(ei.weight_error_scale[tix])); |
| } |
| } |
| |
| // Zero initialize any SIMD over-fetch |
| unsigned int texel_count_simd = round_up_to_simd_multiple_vla(texel_count); |
| for (unsigned int i = texel_count; i < texel_count_simd; i++) |
| { |
| ei.weights[i] = 0.0f; |
| ei.weight_error_scale[i] = 0.0f; |
| } |
| |
| ei.is_constant_weight_error_scale = is_constant_wes; |
| } |
| |
| /* See header for documentation. */ |
| void compute_ideal_colors_and_weights_1plane( |
| const image_block& blk, |
| const partition_info& pi, |
| endpoints_and_weights& ei |
| ) { |
| bool uses_alpha = !blk.is_constant_channel(3); |
| |
| if (uses_alpha) |
| { |
| compute_ideal_colors_and_weights_4_comp(blk, pi, ei); |
| } |
| else |
| { |
| compute_ideal_colors_and_weights_3_comp(blk, pi, ei, 3); |
| } |
| } |
| |
| /* See header for documentation. */ |
| void compute_ideal_colors_and_weights_2planes( |
| const block_size_descriptor& bsd, |
| const image_block& blk, |
| unsigned int plane2_component, |
| endpoints_and_weights& ei1, |
| endpoints_and_weights& ei2 |
| ) { |
| const auto& pi = bsd.get_partition_info(1, 0); |
| bool uses_alpha = !blk.is_constant_channel(3); |
| |
| assert(plane2_component < BLOCK_MAX_COMPONENTS); |
| switch (plane2_component) |
| { |
| case 0: // Separate weights for red |
| if (uses_alpha) |
| { |
| compute_ideal_colors_and_weights_3_comp(blk, pi, ei1, 0); |
| } |
| else |
| { |
| compute_ideal_colors_and_weights_2_comp(blk, pi, ei1, 1, 2); |
| } |
| compute_ideal_colors_and_weights_1_comp(blk, pi, ei2, 0); |
| break; |
| |
| case 1: // Separate weights for green |
| if (uses_alpha) |
| { |
| compute_ideal_colors_and_weights_3_comp(blk, pi, ei1, 1); |
| } |
| else |
| { |
| compute_ideal_colors_and_weights_2_comp(blk, pi, ei1, 0, 2); |
| } |
| compute_ideal_colors_and_weights_1_comp(blk, pi, ei2, 1); |
| break; |
| |
| case 2: // Separate weights for blue |
| if (uses_alpha) |
| { |
| compute_ideal_colors_and_weights_3_comp(blk, pi, ei1, 2); |
| } |
| else |
| { |
| compute_ideal_colors_and_weights_2_comp(blk, pi, ei1, 0, 1); |
| } |
| compute_ideal_colors_and_weights_1_comp(blk, pi, ei2, 2); |
| break; |
| |
| default: // Separate weights for alpha |
| assert(uses_alpha); |
| compute_ideal_colors_and_weights_3_comp(blk, pi, ei1, 3); |
| compute_ideal_colors_and_weights_1_comp(blk, pi, ei2, 3); |
| break; |
| } |
| } |
| |
| /* See header for documentation. */ |
| float compute_error_of_weight_set_1plane( |
| const endpoints_and_weights& eai, |
| const decimation_info& di, |
| const float* dec_weight_quant_uvalue |
| ) { |
| vfloatacc error_summav = vfloatacc::zero(); |
| float error_summa = 0.0f; |
| unsigned int texel_count = di.texel_count; |
| |
| // Process SIMD-width chunks, safe to over-fetch - the extra space is zero initialized |
| if (di.max_texel_weight_count > 2) |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values = bilinear_infill_vla(di, dec_weight_quant_uvalue, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values = loada(eai.weights + i); |
| vfloat diff = current_values - actual_values; |
| vfloat significance = loada(eai.weight_error_scale + i); |
| vfloat error = diff * diff * significance; |
| |
| haccumulate(error_summav, error); |
| } |
| } |
| else if (di.max_texel_weight_count > 1) |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values = bilinear_infill_vla_2(di, dec_weight_quant_uvalue, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values = loada(eai.weights + i); |
| vfloat diff = current_values - actual_values; |
| vfloat significance = loada(eai.weight_error_scale + i); |
| vfloat error = diff * diff * significance; |
| |
| haccumulate(error_summav, error); |
| } |
| } |
| else |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Load the weight set directly, without interpolation |
| vfloat current_values = loada(dec_weight_quant_uvalue + i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values = loada(eai.weights + i); |
| vfloat diff = current_values - actual_values; |
| vfloat significance = loada(eai.weight_error_scale + i); |
| vfloat error = diff * diff * significance; |
| |
| haccumulate(error_summav, error); |
| } |
| } |
| |
| // Resolve the final scalar accumulator sum |
| return error_summa = hadd_s(error_summav); |
| } |
| |
| /* See header for documentation. */ |
| float compute_error_of_weight_set_2planes( |
| const endpoints_and_weights& eai1, |
| const endpoints_and_weights& eai2, |
| const decimation_info& di, |
| const float* dec_weight_quant_uvalue_plane1, |
| const float* dec_weight_quant_uvalue_plane2 |
| ) { |
| vfloatacc error_summav = vfloatacc::zero(); |
| unsigned int texel_count = di.texel_count; |
| |
| // Process SIMD-width chunks, safe to over-fetch - the extra space is zero initialized |
| if (di.max_texel_weight_count > 2) |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Plane 1 |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values1 = bilinear_infill_vla(di, dec_weight_quant_uvalue_plane1, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values1 = loada(eai1.weights + i); |
| vfloat diff = current_values1 - actual_values1; |
| vfloat error1 = diff * diff * loada(eai1.weight_error_scale + i); |
| |
| // Plane 2 |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values2 = bilinear_infill_vla(di, dec_weight_quant_uvalue_plane2, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values2 = loada(eai2.weights + i); |
| diff = current_values2 - actual_values2; |
| vfloat error2 = diff * diff * loada(eai2.weight_error_scale + i); |
| |
| haccumulate(error_summav, error1 + error2); |
| } |
| } |
| else if (di.max_texel_weight_count > 1) |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Plane 1 |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values1 = bilinear_infill_vla_2(di, dec_weight_quant_uvalue_plane1, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values1 = loada(eai1.weights + i); |
| vfloat diff = current_values1 - actual_values1; |
| vfloat error1 = diff * diff * loada(eai1.weight_error_scale + i); |
| |
| // Plane 2 |
| // Compute the bilinear interpolation of the decimated weight grid |
| vfloat current_values2 = bilinear_infill_vla_2(di, dec_weight_quant_uvalue_plane2, i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values2 = loada(eai2.weights + i); |
| diff = current_values2 - actual_values2; |
| vfloat error2 = diff * diff * loada(eai2.weight_error_scale + i); |
| |
| haccumulate(error_summav, error1 + error2); |
| } |
| } |
| else |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Plane 1 |
| // Load the weight set directly, without interpolation |
| vfloat current_values1 = loada(dec_weight_quant_uvalue_plane1 + i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values1 = loada(eai1.weights + i); |
| vfloat diff = current_values1 - actual_values1; |
| vfloat error1 = diff * diff * loada(eai1.weight_error_scale + i); |
| |
| // Plane 2 |
| // Load the weight set directly, without interpolation |
| vfloat current_values2 = loada(dec_weight_quant_uvalue_plane2 + i); |
| |
| // Compute the error between the computed value and the ideal weight |
| vfloat actual_values2 = loada(eai2.weights + i); |
| diff = current_values2 - actual_values2; |
| vfloat error2 = diff * diff * loada(eai2.weight_error_scale + i); |
| |
| haccumulate(error_summav, error1 + error2); |
| } |
| } |
| |
| // Resolve the final scalar accumulator sum |
| return hadd_s(error_summav); |
| } |
| |
| /* See header for documentation. */ |
| void compute_ideal_weights_for_decimation( |
| const endpoints_and_weights& ei, |
| const decimation_info& di, |
| float* dec_weight_ideal_value |
| ) { |
| unsigned int texel_count = di.texel_count; |
| unsigned int weight_count = di.weight_count; |
| bool is_direct = texel_count == weight_count; |
| promise(texel_count > 0); |
| promise(weight_count > 0); |
| |
| // Ensure that the end of the output arrays that are used for SIMD paths later are filled so we |
| // can safely run SIMD elsewhere without a loop tail. Note that this is always safe as weight |
| // arrays always contain space for 64 elements |
| unsigned int prev_weight_count_simd = round_down_to_simd_multiple_vla(weight_count - 1); |
| storea(vfloat::zero(), dec_weight_ideal_value + prev_weight_count_simd); |
| |
| // If we have a 1:1 mapping just shortcut the computation. Transfer enough to also copy the |
| // zero-initialized SIMD over-fetch region |
| if (is_direct) |
| { |
| unsigned int texel_count_simd = round_up_to_simd_multiple_vla(texel_count); |
| for (unsigned int i = 0; i < texel_count_simd; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight(ei.weights + i); |
| storea(weight, dec_weight_ideal_value + i); |
| } |
| |
| return; |
| } |
| |
| // Otherwise compute an estimate and perform single refinement iteration |
| alignas(ASTCENC_VECALIGN) float infilled_weights[BLOCK_MAX_TEXELS]; |
| |
| // Compute an initial average for each decimated weight |
| bool constant_wes = ei.is_constant_weight_error_scale; |
| vfloat weight_error_scale(ei.weight_error_scale[0]); |
| |
| // This overshoots - this is OK as we initialize the array tails in the |
| // decimation table structures to safe values ... |
| for (unsigned int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| // Start with a small value to avoid div-by-zero later |
| vfloat weight_weight(1e-10f); |
| vfloat initial_weight = vfloat::zero(); |
| |
| // Accumulate error weighting of all the texels using this weight |
| vint weight_texel_count(di.weight_texel_count + i); |
| unsigned int max_texel_count = hmax(weight_texel_count).lane<0>(); |
| promise(max_texel_count > 0); |
| |
| for (unsigned int j = 0; j < max_texel_count; j++) |
| { |
| vint texel(di.weight_texel[j] + i); |
| vfloat weight = loada(di.weights_flt[j] + i); |
| |
| if (!constant_wes) |
| { |
| weight_error_scale = gatherf(ei.weight_error_scale, texel); |
| } |
| |
| vfloat contrib_weight = weight * weight_error_scale; |
| |
| weight_weight += contrib_weight; |
| initial_weight += gatherf(ei.weights, texel) * contrib_weight; |
| } |
| |
| storea(initial_weight / weight_weight, dec_weight_ideal_value + i); |
| } |
| |
| // Populate the interpolated weight grid based on the initial average |
| // Process SIMD-width texel coordinates at at time while we can. Safe to |
| // over-process full SIMD vectors - the tail is zeroed. |
| if (di.max_texel_weight_count <= 2) |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla_2(di, dec_weight_ideal_value, i); |
| storea(weight, infilled_weights + i); |
| } |
| } |
| else |
| { |
| for (unsigned int i = 0; i < texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla(di, dec_weight_ideal_value, i); |
| storea(weight, infilled_weights + i); |
| } |
| } |
| |
| // Perform a single iteration of refinement |
| // Empirically determined step size; larger values don't help but smaller drops image quality |
| constexpr float stepsize = 0.25f; |
| constexpr float chd_scale = -WEIGHTS_TEXEL_SUM; |
| |
| for (unsigned int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight_val = loada(dec_weight_ideal_value + i); |
| |
| // Accumulate error weighting of all the texels using this weight |
| // Start with a small value to avoid div-by-zero later |
| vfloat error_change0(1e-10f); |
| vfloat error_change1(0.0f); |
| |
| // Accumulate error weighting of all the texels using this weight |
| vint weight_texel_count(di.weight_texel_count + i); |
| unsigned int max_texel_count = hmax(weight_texel_count).lane<0>(); |
| promise(max_texel_count > 0); |
| |
| for (unsigned int j = 0; j < max_texel_count; j++) |
| { |
| vint texel(di.weight_texel[j] + i); |
| vfloat contrib_weight = loada(di.weights_flt[j] + i); |
| |
| if (!constant_wes) |
| { |
| weight_error_scale = gatherf(ei.weight_error_scale, texel); |
| } |
| |
| vfloat scale = weight_error_scale * contrib_weight; |
| vfloat old_weight = gatherf(infilled_weights, texel); |
| vfloat ideal_weight = gatherf(ei.weights, texel); |
| |
| error_change0 += contrib_weight * scale; |
| error_change1 += (old_weight - ideal_weight) * scale; |
| } |
| |
| vfloat step = (error_change1 * chd_scale) / error_change0; |
| step = clamp(-stepsize, stepsize, step); |
| |
| // Update the weight; note this can store negative values. |
| storea(weight_val + step, dec_weight_ideal_value + i); |
| } |
| } |
| |
| /* See header for documentation. */ |
| void compute_quantized_weights_for_decimation( |
| const decimation_info& di, |
| float low_bound, |
| float high_bound, |
| const float* dec_weight_ideal_value, |
| float* weight_set_out, |
| uint8_t* quantized_weight_set, |
| quant_method quant_level |
| ) { |
| int weight_count = di.weight_count; |
| promise(weight_count > 0); |
| const quant_and_transfer_table& qat = quant_and_xfer_tables[quant_level]; |
| |
| // The available quant levels, stored with a minus 1 bias |
| static const float quant_levels_m1[12] { |
| 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 7.0f, 9.0f, 11.0f, 15.0f, 19.0f, 23.0f, 31.0f |
| }; |
| |
| vint steps_m1(get_quant_level(quant_level) - 1); |
| float quant_level_m1 = quant_levels_m1[quant_level]; |
| |
| // Quantize the weight set using both the specified low/high bounds and standard 0..1 bounds |
| |
| // TODO: Oddity to investigate; triggered by test in issue #265. |
| if (high_bound <= low_bound) |
| { |
| low_bound = 0.0f; |
| high_bound = 1.0f; |
| } |
| |
| float rscale = high_bound - low_bound; |
| float scale = 1.0f / rscale; |
| |
| float scaled_low_bound = low_bound * scale; |
| rscale *= 1.0f / 64.0f; |
| |
| vfloat scalev(scale); |
| vfloat scaled_low_boundv(scaled_low_bound); |
| vfloat quant_level_m1v(quant_level_m1); |
| vfloat rscalev(rscale); |
| vfloat low_boundv(low_bound); |
| |
| // This runs to the rounded-up SIMD size, which is safe as the loop tail is filled with known |
| // safe data in compute_ideal_weights_for_decimation and arrays are always 64 elements |
| if (get_quant_level(quant_level) <= 16) |
| { |
| vint4 tab0(reinterpret_cast<const int*>(qat.quant_to_unquant)); |
| vint tab0p; |
| vtable_prepare(tab0, tab0p); |
| |
| for (int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat ix = loada(dec_weight_ideal_value + i) * scalev - scaled_low_boundv; |
| ix = clampzo(ix); |
| |
| // Look up the two closest indexes and return the one that was closest |
| vfloat ix1 = ix * quant_level_m1v; |
| |
| vint weightl = float_to_int(ix1); |
| vint weighth = min(weightl + vint(1), steps_m1); |
| |
| vint ixli = vtable_8bt_32bi(tab0p, weightl); |
| vint ixhi = vtable_8bt_32bi(tab0p, weighth); |
| |
| vfloat ixl = int_to_float(ixli); |
| vfloat ixh = int_to_float(ixhi); |
| |
| vmask mask = (ixl + ixh) < (vfloat(128.0f) * ix); |
| vint weight = select(ixli, ixhi, mask); |
| ixl = select(ixl, ixh, mask); |
| |
| // Invert the weight-scaling that was done initially |
| storea(ixl * rscalev + low_boundv, weight_set_out + i); |
| vint scn = pack_low_bytes(weight); |
| store_nbytes(scn, quantized_weight_set + i); |
| } |
| } |
| else |
| { |
| vint4 tab0(reinterpret_cast<const int*>(qat.quant_to_unquant)); |
| vint4 tab1(reinterpret_cast<const int*>(qat.quant_to_unquant + 16)); |
| vint tab0p, tab1p; |
| vtable_prepare(tab0, tab1, tab0p, tab1p); |
| |
| for (int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat ix = loada(dec_weight_ideal_value + i) * scalev - scaled_low_boundv; |
| ix = clampzo(ix); |
| |
| // Look up the two closest indexes and return the one that was closest |
| vfloat ix1 = ix * quant_level_m1v; |
| |
| vint weightl = float_to_int(ix1); |
| vint weighth = min(weightl + vint(1), steps_m1); |
| |
| vint ixli = vtable_8bt_32bi(tab0p, tab1p, weightl); |
| vint ixhi = vtable_8bt_32bi(tab0p, tab1p, weighth); |
| |
| vfloat ixl = int_to_float(ixli); |
| vfloat ixh = int_to_float(ixhi); |
| |
| vmask mask = (ixl + ixh) < (vfloat(128.0f) * ix); |
| vint weight = select(ixli, ixhi, mask); |
| ixl = select(ixl, ixh, mask); |
| |
| // Invert the weight-scaling that was done initially |
| storea(ixl * rscalev + low_boundv, weight_set_out + i); |
| vint scn = pack_low_bytes(weight); |
| store_nbytes(scn, quantized_weight_set + i); |
| } |
| } |
| } |
| |
| /** |
| * @brief Compute the RGB + offset for a HDR endpoint mode #7. |
| * |
| * Since the matrix needed has a regular structure we can simplify the inverse calculation. This |
| * gives us ~24 multiplications vs. 96 for a generic inverse. |
| * |
| * mat[0] = vfloat4(rgba_ws.x, 0.0f, 0.0f, wght_ws.x); |
| * mat[1] = vfloat4( 0.0f, rgba_ws.y, 0.0f, wght_ws.y); |
| * mat[2] = vfloat4( 0.0f, 0.0f, rgba_ws.z, wght_ws.z); |
| * mat[3] = vfloat4(wght_ws.x, wght_ws.y, wght_ws.z, psum); |
| * mat = invert(mat); |
| * |
| * @param rgba_weight_sum Sum of partition component error weights. |
| * @param weight_weight_sum Sum of partition component error weights * texel weight. |
| * @param rgbq_sum Sum of partition component error weights * texel weight * color data. |
| * @param psum Sum of RGB color weights * texel weight^2. |
| */ |
| static inline vfloat4 compute_rgbo_vector( |
| vfloat4 rgba_weight_sum, |
| vfloat4 weight_weight_sum, |
| vfloat4 rgbq_sum, |
| float psum |
| ) { |
| float X = rgba_weight_sum.lane<0>(); |
| float Y = rgba_weight_sum.lane<1>(); |
| float Z = rgba_weight_sum.lane<2>(); |
| float P = weight_weight_sum.lane<0>(); |
| float Q = weight_weight_sum.lane<1>(); |
| float R = weight_weight_sum.lane<2>(); |
| float S = psum; |
| |
| float PP = P * P; |
| float QQ = Q * Q; |
| float RR = R * R; |
| |
| float SZmRR = S * Z - RR; |
| float DT = SZmRR * Y - Z * QQ; |
| float YP = Y * P; |
| float QX = Q * X; |
| float YX = Y * X; |
| float mZYP = -Z * YP; |
| float mZQX = -Z * QX; |
| float mRYX = -R * YX; |
| float ZQP = Z * Q * P; |
| float RYP = R * YP; |
| float RQX = R * QX; |
| |
| // Compute the reciprocal of matrix determinant |
| float rdet = 1.0f / (DT * X + mZYP * P); |
| |
| // Actually compute the adjugate, and then apply 1/det separately |
| vfloat4 mat0(DT, ZQP, RYP, mZYP); |
| vfloat4 mat1(ZQP, SZmRR * X - Z * PP, RQX, mZQX); |
| vfloat4 mat2(RYP, RQX, (S * Y - QQ) * X - Y * PP, mRYX); |
| vfloat4 mat3(mZYP, mZQX, mRYX, Z * YX); |
| vfloat4 vect = rgbq_sum * rdet; |
| |
| return vfloat4(dot_s(mat0, vect), |
| dot_s(mat1, vect), |
| dot_s(mat2, vect), |
| dot_s(mat3, vect)); |
| } |
| |
| /* See header for documentation. */ |
| void recompute_ideal_colors_1plane( |
| const image_block& blk, |
| const partition_info& pi, |
| const decimation_info& di, |
| const uint8_t* dec_weights_uquant, |
| endpoints& ep, |
| vfloat4 rgbs_vectors[BLOCK_MAX_PARTITIONS], |
| vfloat4 rgbo_vectors[BLOCK_MAX_PARTITIONS] |
| ) { |
| unsigned int weight_count = di.weight_count; |
| unsigned int total_texel_count = blk.texel_count; |
| unsigned int partition_count = pi.partition_count; |
| |
| promise(weight_count > 0); |
| promise(total_texel_count > 0); |
| promise(partition_count > 0); |
| |
| alignas(ASTCENC_VECALIGN) float dec_weight[BLOCK_MAX_WEIGHTS]; |
| for (unsigned int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vint unquant_value(dec_weights_uquant + i); |
| vfloat unquant_valuef = int_to_float(unquant_value) * vfloat(1.0f / 64.0f); |
| storea(unquant_valuef, dec_weight + i); |
| } |
| |
| alignas(ASTCENC_VECALIGN) float undec_weight[BLOCK_MAX_TEXELS]; |
| float* undec_weight_ref; |
| if (di.max_texel_weight_count == 1) |
| { |
| undec_weight_ref = dec_weight; |
| } |
| else if (di.max_texel_weight_count <= 2) |
| { |
| for (unsigned int i = 0; i < total_texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla_2(di, dec_weight, i); |
| storea(weight, undec_weight + i); |
| } |
| |
| undec_weight_ref = undec_weight; |
| } |
| else |
| { |
| for (unsigned int i = 0; i < total_texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla(di, dec_weight, i); |
| storea(weight, undec_weight + i); |
| } |
| |
| undec_weight_ref = undec_weight; |
| } |
| |
| vfloat4 rgba_sum(blk.data_mean * static_cast<float>(blk.texel_count)); |
| |
| for (unsigned int i = 0; i < partition_count; i++) |
| { |
| unsigned int texel_count = pi.partition_texel_count[i]; |
| const uint8_t *texel_indexes = pi.texels_of_partition[i]; |
| |
| // Only compute a partition mean if more than one partition |
| if (partition_count > 1) |
| { |
| rgba_sum = vfloat4(1e-17f); |
| promise(texel_count > 0); |
| for (unsigned int j = 0; j < texel_count; j++) |
| { |
| unsigned int tix = texel_indexes[j]; |
| rgba_sum += blk.texel(tix); |
| } |
| } |
| |
| rgba_sum = rgba_sum * blk.channel_weight; |
| vfloat4 rgba_weight_sum = max(blk.channel_weight * static_cast<float>(texel_count), 1e-17f); |
| vfloat4 scale_dir = normalize((rgba_sum / rgba_weight_sum).swz<0, 1, 2>()); |
| |
| float scale_max = 0.0f; |
| float scale_min = 1e10f; |
| |
| float wmin1 = 1.0f; |
| float wmax1 = 0.0f; |
| |
| float left_sum_s = 0.0f; |
| float middle_sum_s = 0.0f; |
| float right_sum_s = 0.0f; |
| |
| vfloat4 color_vec_x = vfloat4::zero(); |
| vfloat4 color_vec_y = vfloat4::zero(); |
| |
| vfloat4 scale_vec = vfloat4::zero(); |
| |
| float weight_weight_sum_s = 1e-17f; |
| |
| vfloat4 color_weight = blk.channel_weight; |
| float ls_weight = hadd_rgb_s(color_weight); |
| |
| for (unsigned int j = 0; j < texel_count; j++) |
| { |
| unsigned int tix = texel_indexes[j]; |
| |
| vfloat4 rgba = blk.texel(tix); |
| |
| float idx0 = undec_weight_ref[tix]; |
| |
| float om_idx0 = 1.0f - idx0; |
| wmin1 = astc::min(idx0, wmin1); |
| wmax1 = astc::max(idx0, wmax1); |
| |
| float scale = dot3_s(scale_dir, rgba); |
| scale_min = astc::min(scale, scale_min); |
| scale_max = astc::max(scale, scale_max); |
| |
| left_sum_s += om_idx0 * om_idx0; |
| middle_sum_s += om_idx0 * idx0; |
| right_sum_s += idx0 * idx0; |
| weight_weight_sum_s += idx0; |
| |
| vfloat4 color_idx(idx0); |
| vfloat4 cwprod = rgba; |
| vfloat4 cwiprod = cwprod * color_idx; |
| |
| color_vec_y += cwiprod; |
| color_vec_x += cwprod - cwiprod; |
| |
| scale_vec += vfloat2(om_idx0, idx0) * (scale * ls_weight); |
| } |
| |
| vfloat4 left_sum = vfloat4(left_sum_s) * color_weight; |
| vfloat4 middle_sum = vfloat4(middle_sum_s) * color_weight; |
| vfloat4 right_sum = vfloat4(right_sum_s) * color_weight; |
| vfloat4 lmrs_sum = vfloat3(left_sum_s, middle_sum_s, right_sum_s) * ls_weight; |
| |
| vfloat4 weight_weight_sum = vfloat4(weight_weight_sum_s) * color_weight; |
| float psum = right_sum_s * hadd_rgb_s(color_weight); |
| |
| color_vec_x = color_vec_x * color_weight; |
| color_vec_y = color_vec_y * color_weight; |
| |
| // Initialize the luminance and scale vectors with a reasonable default |
| float scalediv = scale_min / astc::max(scale_max, 1e-10f); |
| scalediv = astc::clamp1f(scalediv); |
| |
| vfloat4 sds = scale_dir * scale_max; |
| |
| rgbs_vectors[i] = vfloat4(sds.lane<0>(), sds.lane<1>(), sds.lane<2>(), scalediv); |
| |
| if (wmin1 >= wmax1 * 0.999f) |
| { |
| // If all weights in the partition were equal, then just take average of all colors in |
| // the partition and use that as both endpoint colors |
| vfloat4 avg = (color_vec_x + color_vec_y) / rgba_weight_sum; |
| |
| vmask4 notnan_mask = avg == avg; |
| ep.endpt0[i] = select(ep.endpt0[i], avg, notnan_mask); |
| ep.endpt1[i] = select(ep.endpt1[i], avg, notnan_mask); |
| |
| rgbs_vectors[i] = vfloat4(sds.lane<0>(), sds.lane<1>(), sds.lane<2>(), 1.0f); |
| } |
| else |
| { |
| // Otherwise, complete the analytic calculation of ideal-endpoint-values for the given |
| // set of texel weights and pixel colors |
| vfloat4 color_det1 = (left_sum * right_sum) - (middle_sum * middle_sum); |
| vfloat4 color_rdet1 = 1.0f / color_det1; |
| |
| float ls_det1 = (lmrs_sum.lane<0>() * lmrs_sum.lane<2>()) - (lmrs_sum.lane<1>() * lmrs_sum.lane<1>()); |
| float ls_rdet1 = 1.0f / ls_det1; |
| |
| vfloat4 color_mss1 = (left_sum * left_sum) |
| + (2.0f * middle_sum * middle_sum) |
| + (right_sum * right_sum); |
| |
| float ls_mss1 = (lmrs_sum.lane<0>() * lmrs_sum.lane<0>()) |
| + (2.0f * lmrs_sum.lane<1>() * lmrs_sum.lane<1>()) |
| + (lmrs_sum.lane<2>() * lmrs_sum.lane<2>()); |
| |
| vfloat4 ep0 = (right_sum * color_vec_x - middle_sum * color_vec_y) * color_rdet1; |
| vfloat4 ep1 = (left_sum * color_vec_y - middle_sum * color_vec_x) * color_rdet1; |
| |
| vmask4 det_mask = abs(color_det1) > (color_mss1 * 1e-4f); |
| vmask4 notnan_mask = (ep0 == ep0) & (ep1 == ep1); |
| vmask4 full_mask = det_mask & notnan_mask; |
| |
| ep.endpt0[i] = select(ep.endpt0[i], ep0, full_mask); |
| ep.endpt1[i] = select(ep.endpt1[i], ep1, full_mask); |
| |
| float scale_ep0 = (lmrs_sum.lane<2>() * scale_vec.lane<0>() - lmrs_sum.lane<1>() * scale_vec.lane<1>()) * ls_rdet1; |
| float scale_ep1 = (lmrs_sum.lane<0>() * scale_vec.lane<1>() - lmrs_sum.lane<1>() * scale_vec.lane<0>()) * ls_rdet1; |
| |
| if (fabsf(ls_det1) > (ls_mss1 * 1e-4f) && scale_ep0 == scale_ep0 && scale_ep1 == scale_ep1 && scale_ep0 < scale_ep1) |
| { |
| float scalediv2 = scale_ep0 / scale_ep1; |
| vfloat4 sdsm = scale_dir * scale_ep1; |
| rgbs_vectors[i] = vfloat4(sdsm.lane<0>(), sdsm.lane<1>(), sdsm.lane<2>(), scalediv2); |
| } |
| } |
| |
| // Calculations specific to mode #7, the HDR RGB-scale mode |
| vfloat4 rgbq_sum = color_vec_x + color_vec_y; |
| rgbq_sum.set_lane<3>(hadd_rgb_s(color_vec_y)); |
| |
| vfloat4 rgbovec = compute_rgbo_vector(rgba_weight_sum, weight_weight_sum, rgbq_sum, psum); |
| rgbo_vectors[i] = rgbovec; |
| |
| // We can get a failure due to the use of a singular (non-invertible) matrix |
| // If it failed, compute rgbo_vectors[] with a different method ... |
| if (astc::isnan(dot_s(rgbovec, rgbovec))) |
| { |
| vfloat4 v0 = ep.endpt0[i]; |
| vfloat4 v1 = ep.endpt1[i]; |
| |
| float avgdif = hadd_rgb_s(v1 - v0) * (1.0f / 3.0f); |
| avgdif = astc::max(avgdif, 0.0f); |
| |
| vfloat4 avg = (v0 + v1) * 0.5f; |
| vfloat4 ep0 = avg - vfloat4(avgdif) * 0.5f; |
| rgbo_vectors[i] = vfloat4(ep0.lane<0>(), ep0.lane<1>(), ep0.lane<2>(), avgdif); |
| } |
| } |
| } |
| |
| /* See header for documentation. */ |
| void recompute_ideal_colors_2planes( |
| const image_block& blk, |
| const block_size_descriptor& bsd, |
| const decimation_info& di, |
| const uint8_t* dec_weights_uquant_plane1, |
| const uint8_t* dec_weights_uquant_plane2, |
| endpoints& ep, |
| vfloat4& rgbs_vector, |
| vfloat4& rgbo_vector, |
| int plane2_component |
| ) { |
| unsigned int weight_count = di.weight_count; |
| unsigned int total_texel_count = blk.texel_count; |
| |
| promise(total_texel_count > 0); |
| promise(weight_count > 0); |
| |
| alignas(ASTCENC_VECALIGN) float dec_weight_plane1[BLOCK_MAX_WEIGHTS_2PLANE]; |
| alignas(ASTCENC_VECALIGN) float dec_weight_plane2[BLOCK_MAX_WEIGHTS_2PLANE]; |
| |
| assert(weight_count <= BLOCK_MAX_WEIGHTS_2PLANE); |
| |
| for (unsigned int i = 0; i < weight_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vint unquant_value1(dec_weights_uquant_plane1 + i); |
| vfloat unquant_value1f = int_to_float(unquant_value1) * vfloat(1.0f / 64.0f); |
| storea(unquant_value1f, dec_weight_plane1 + i); |
| |
| vint unquant_value2(dec_weights_uquant_plane2 + i); |
| vfloat unquant_value2f = int_to_float(unquant_value2) * vfloat(1.0f / 64.0f); |
| storea(unquant_value2f, dec_weight_plane2 + i); |
| } |
| |
| alignas(ASTCENC_VECALIGN) float undec_weight_plane1[BLOCK_MAX_TEXELS]; |
| alignas(ASTCENC_VECALIGN) float undec_weight_plane2[BLOCK_MAX_TEXELS]; |
| |
| float* undec_weight_plane1_ref; |
| float* undec_weight_plane2_ref; |
| |
| if (di.max_texel_weight_count == 1) |
| { |
| undec_weight_plane1_ref = dec_weight_plane1; |
| undec_weight_plane2_ref = dec_weight_plane2; |
| } |
| else if (di.max_texel_weight_count <= 2) |
| { |
| for (unsigned int i = 0; i < total_texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla_2(di, dec_weight_plane1, i); |
| storea(weight, undec_weight_plane1 + i); |
| |
| weight = bilinear_infill_vla_2(di, dec_weight_plane2, i); |
| storea(weight, undec_weight_plane2 + i); |
| } |
| |
| undec_weight_plane1_ref = undec_weight_plane1; |
| undec_weight_plane2_ref = undec_weight_plane2; |
| } |
| else |
| { |
| for (unsigned int i = 0; i < total_texel_count; i += ASTCENC_SIMD_WIDTH) |
| { |
| vfloat weight = bilinear_infill_vla(di, dec_weight_plane1, i); |
| storea(weight, undec_weight_plane1 + i); |
| |
| weight = bilinear_infill_vla(di, dec_weight_plane2, i); |
| storea(weight, undec_weight_plane2 + i); |
| } |
| |
| undec_weight_plane1_ref = undec_weight_plane1; |
| undec_weight_plane2_ref = undec_weight_plane2; |
| } |
| |
| unsigned int texel_count = bsd.texel_count; |
| vfloat4 rgba_weight_sum = max(blk.channel_weight * static_cast<float>(texel_count), 1e-17f); |
| vfloat4 scale_dir = normalize(blk.data_mean.swz<0, 1, 2>()); |
| |
| float scale_max = 0.0f; |
| float scale_min = 1e10f; |
| |
| float wmin1 = 1.0f; |
| float wmax1 = 0.0f; |
| |
| float wmin2 = 1.0f; |
| float wmax2 = 0.0f; |
| |
| float left1_sum_s = 0.0f; |
| float middle1_sum_s = 0.0f; |
| float right1_sum_s = 0.0f; |
| |
| float left2_sum_s = 0.0f; |
| float middle2_sum_s = 0.0f; |
| float right2_sum_s = 0.0f; |
| |
| vfloat4 color_vec_x = vfloat4::zero(); |
| vfloat4 color_vec_y = vfloat4::zero(); |
| |
| vfloat4 scale_vec = vfloat4::zero(); |
| |
| vfloat4 weight_weight_sum = vfloat4(1e-17f); |
| |
| vmask4 p2_mask = vint4::lane_id() == vint4(plane2_component); |
| vfloat4 color_weight = blk.channel_weight; |
| float ls_weight = hadd_rgb_s(color_weight); |
| |
| for (unsigned int j = 0; j < texel_count; j++) |
| { |
| vfloat4 rgba = blk.texel(j); |
| |
| float idx0 = undec_weight_plane1_ref[j]; |
| |
| float om_idx0 = 1.0f - idx0; |
| wmin1 = astc::min(idx0, wmin1); |
| wmax1 = astc::max(idx0, wmax1); |
| |
| float scale = dot3_s(scale_dir, rgba); |
| scale_min = astc::min(scale, scale_min); |
| scale_max = astc::max(scale, scale_max); |
| |
| left1_sum_s += om_idx0 * om_idx0; |
| middle1_sum_s += om_idx0 * idx0; |
| right1_sum_s += idx0 * idx0; |
| |
| float idx1 = undec_weight_plane2_ref[j]; |
| |
| float om_idx1 = 1.0f - idx1; |
| wmin2 = astc::min(idx1, wmin2); |
| wmax2 = astc::max(idx1, wmax2); |
| |
| left2_sum_s += om_idx1 * om_idx1; |
| middle2_sum_s += om_idx1 * idx1; |
| right2_sum_s += idx1 * idx1; |
| |
| vfloat4 color_idx = select(vfloat4(idx0), vfloat4(idx1), p2_mask); |
| |
| vfloat4 cwprod = rgba; |
| vfloat4 cwiprod = cwprod * color_idx; |
| |
| color_vec_y += cwiprod; |
| color_vec_x += cwprod - cwiprod; |
| |
| scale_vec += vfloat2(om_idx0, idx0) * (ls_weight * scale); |
| weight_weight_sum += (color_weight * color_idx); |
| } |
| |
| vfloat4 left1_sum = vfloat4(left1_sum_s) * color_weight; |
| vfloat4 middle1_sum = vfloat4(middle1_sum_s) * color_weight; |
| vfloat4 right1_sum = vfloat4(right1_sum_s) * color_weight; |
| vfloat4 lmrs_sum = vfloat3(left1_sum_s, middle1_sum_s, right1_sum_s) * ls_weight; |
| |
| vfloat4 left2_sum = vfloat4(left2_sum_s) * color_weight; |
| vfloat4 middle2_sum = vfloat4(middle2_sum_s) * color_weight; |
| vfloat4 right2_sum = vfloat4(right2_sum_s) * color_weight; |
| |
| float psum = dot3_s(select(right1_sum, right2_sum, p2_mask), color_weight); |
| |
| color_vec_x = color_vec_x * color_weight; |
| color_vec_y = color_vec_y * color_weight; |
| |
| // Initialize the luminance and scale vectors with a reasonable default |
| float scalediv = scale_min / astc::max(scale_max, 1e-10f); |
| scalediv = astc::clamp1f(scalediv); |
| |
| vfloat4 sds = scale_dir * scale_max; |
| |
| rgbs_vector = vfloat4(sds.lane<0>(), sds.lane<1>(), sds.lane<2>(), scalediv); |
| |
| if (wmin1 >= wmax1 * 0.999f) |
| { |
| // If all weights in the partition were equal, then just take average of all colors in |
| // the partition and use that as both endpoint colors |
| vfloat4 avg = (color_vec_x + color_vec_y) / rgba_weight_sum; |
| |
| vmask4 p1_mask = vint4::lane_id() != vint4(plane2_component); |
| vmask4 notnan_mask = avg == avg; |
| vmask4 full_mask = p1_mask & notnan_mask; |
| |
| ep.endpt0[0] = select(ep.endpt0[0], avg, full_mask); |
| ep.endpt1[0] = select(ep.endpt1[0], avg, full_mask); |
| |
| rgbs_vector = vfloat4(sds.lane<0>(), sds.lane<1>(), sds.lane<2>(), 1.0f); |
| } |
| else |
| { |
| // Otherwise, complete the analytic calculation of ideal-endpoint-values for the given |
| // set of texel weights and pixel colors |
| vfloat4 color_det1 = (left1_sum * right1_sum) - (middle1_sum * middle1_sum); |
| vfloat4 color_rdet1 = 1.0f / color_det1; |
| |
| float ls_det1 = (lmrs_sum.lane<0>() * lmrs_sum.lane<2>()) - (lmrs_sum.lane<1>() * lmrs_sum.lane<1>()); |
| float ls_rdet1 = 1.0f / ls_det1; |
| |
| vfloat4 color_mss1 = (left1_sum * left1_sum) |
| + (2.0f * middle1_sum * middle1_sum) |
| + (right1_sum * right1_sum); |
| |
| float ls_mss1 = (lmrs_sum.lane<0>() * lmrs_sum.lane<0>()) |
| + (2.0f * lmrs_sum.lane<1>() * lmrs_sum.lane<1>()) |
| + (lmrs_sum.lane<2>() * lmrs_sum.lane<2>()); |
| |
| vfloat4 ep0 = (right1_sum * color_vec_x - middle1_sum * color_vec_y) * color_rdet1; |
| vfloat4 ep1 = (left1_sum * color_vec_y - middle1_sum * color_vec_x) * color_rdet1; |
| |
| float scale_ep0 = (lmrs_sum.lane<2>() * scale_vec.lane<0>() - lmrs_sum.lane<1>() * scale_vec.lane<1>()) * ls_rdet1; |
| float scale_ep1 = (lmrs_sum.lane<0>() * scale_vec.lane<1>() - lmrs_sum.lane<1>() * scale_vec.lane<0>()) * ls_rdet1; |
| |
| vmask4 p1_mask = vint4::lane_id() != vint4(plane2_component); |
| vmask4 det_mask = abs(color_det1) > (color_mss1 * 1e-4f); |
| vmask4 notnan_mask = (ep0 == ep0) & (ep1 == ep1); |
| vmask4 full_mask = p1_mask & det_mask & notnan_mask; |
| |
| ep.endpt0[0] = select(ep.endpt0[0], ep0, full_mask); |
| ep.endpt1[0] = select(ep.endpt1[0], ep1, full_mask); |
| |
| if (fabsf(ls_det1) > (ls_mss1 * 1e-4f) && scale_ep0 == scale_ep0 && scale_ep1 == scale_ep1 && scale_ep0 < scale_ep1) |
| { |
| float scalediv2 = scale_ep0 / scale_ep1; |
| vfloat4 sdsm = scale_dir * scale_ep1; |
| rgbs_vector = vfloat4(sdsm.lane<0>(), sdsm.lane<1>(), sdsm.lane<2>(), scalediv2); |
| } |
| } |
| |
| if (wmin2 >= wmax2 * 0.999f) |
| { |
| // If all weights in the partition were equal, then just take average of all colors in |
| // the partition and use that as both endpoint colors |
| vfloat4 avg = (color_vec_x + color_vec_y) / rgba_weight_sum; |
| |
| vmask4 notnan_mask = avg == avg; |
| vmask4 full_mask = p2_mask & notnan_mask; |
| |
| ep.endpt0[0] = select(ep.endpt0[0], avg, full_mask); |
| ep.endpt1[0] = select(ep.endpt1[0], avg, full_mask); |
| } |
| else |
| { |
| // Otherwise, complete the analytic calculation of ideal-endpoint-values for the given |
| // set of texel weights and pixel colors |
| vfloat4 color_det2 = (left2_sum * right2_sum) - (middle2_sum * middle2_sum); |
| vfloat4 color_rdet2 = 1.0f / color_det2; |
| |
| vfloat4 color_mss2 = (left2_sum * left2_sum) |
| + (2.0f * middle2_sum * middle2_sum) |
| + (right2_sum * right2_sum); |
| |
| vfloat4 ep0 = (right2_sum * color_vec_x - middle2_sum * color_vec_y) * color_rdet2; |
| vfloat4 ep1 = (left2_sum * color_vec_y - middle2_sum * color_vec_x) * color_rdet2; |
| |
| vmask4 det_mask = abs(color_det2) > (color_mss2 * 1e-4f); |
| vmask4 notnan_mask = (ep0 == ep0) & (ep1 == ep1); |
| vmask4 full_mask = p2_mask & det_mask & notnan_mask; |
| |
| ep.endpt0[0] = select(ep.endpt0[0], ep0, full_mask); |
| ep.endpt1[0] = select(ep.endpt1[0], ep1, full_mask); |
| } |
| |
| // Calculations specific to mode #7, the HDR RGB-scale mode |
| vfloat4 rgbq_sum = color_vec_x + color_vec_y; |
| rgbq_sum.set_lane<3>(hadd_rgb_s(color_vec_y)); |
| |
| rgbo_vector = compute_rgbo_vector(rgba_weight_sum, weight_weight_sum, rgbq_sum, psum); |
| |
| // We can get a failure due to the use of a singular (non-invertible) matrix |
| // If it failed, compute rgbo_vectors[] with a different method ... |
| if (astc::isnan(dot_s(rgbo_vector, rgbo_vector))) |
| { |
| vfloat4 v0 = ep.endpt0[0]; |
| vfloat4 v1 = ep.endpt1[0]; |
| |
| float avgdif = hadd_rgb_s(v1 - v0) * (1.0f / 3.0f); |
| avgdif = astc::max(avgdif, 0.0f); |
| |
| vfloat4 avg = (v0 + v1) * 0.5f; |
| vfloat4 ep0 = avg - vfloat4(avgdif) * 0.5f; |
| |
| rgbo_vector = vfloat4(ep0.lane<0>(), ep0.lane<1>(), ep0.lane<2>(), avgdif); |
| } |
| } |
| |
| #endif |