Index: cc/resources/texture_compressor_etc1_sse.cc |
diff --git a/cc/resources/texture_compressor_etc1_sse.cc b/cc/resources/texture_compressor_etc1_sse.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..ea996b8245345c0ea9466d961cf07d9879e8d06a |
--- /dev/null |
+++ b/cc/resources/texture_compressor_etc1_sse.cc |
@@ -0,0 +1,820 @@ |
+// Copyright 2015 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "texture_compressor_etc1_sse.h" |
+ |
+#include <assert.h> |
+#include <emmintrin.h> |
+#include <stdio.h> |
+#include <stdlib.h> |
+#include <string.h> |
+#include <time.h> |
+ |
+#include <cmath> |
+#include <limits> |
+#include <sstream> |
+ |
+#include "base/compiler_specific.h" |
+#include "base/logging.h" |
+#include "cc/resources/texture_compressor_util.h" |
+ |
+using namespace cc::texture_compress; |
+ |
+namespace { |
+ |
+#define ETC1_SET_ERROR(x) (x + x / 2 + 384) |
+ |
+struct __sse_data { |
+ /* raw data */ |
+ uint8_t* block; |
+ /* 8 bit packed values */ |
+ __m128i* packed; |
+ /* 32 bit zero extended values - 4x4 arrays */ |
+ __m128i* blue; |
+ __m128i* green; |
+ __m128i* red; |
+ // __m128i *alpha; |
+}; |
+ |
+/* commonly used registers */ |
+static const __m128i __sse_zero = _mm_set1_epi32(0); |
+static const __m128i __sse_max_int = _mm_set1_epi32(0x7FFFFFFF); |
+ |
+inline __m128i AddAndClamp(const __m128i x, const __m128i y) { |
+ static const __m128i color_max = _mm_set1_epi32(0xFF); |
+ return _mm_max_epi16(__sse_zero, |
+ _mm_min_epi16(_mm_add_epi16(x, y), color_max)); |
+} |
+ |
+inline __m128i GetColorErrorSSE(const __m128i x, const __m128i y) { |
+ /* changed from _mm_mullo_epi32 to _mm_mullo_epi16 */ |
+ __m128i ret = _mm_sub_epi16(x, y); |
+ return _mm_mullo_epi16(ret, ret); |
+} |
+ |
+inline __m128i AddChannelError(const __m128i x, |
+ const __m128i y, |
+ const __m128i z) { |
+ return _mm_add_epi32(x, _mm_add_epi32(y, z)); |
+} |
+ |
+inline uint32_t SumSSE(const __m128i x) { |
+ __m128i sum = _mm_add_epi32(x, _mm_shuffle_epi32(x, 0x4E)); |
+ sum = _mm_add_epi32(sum, _mm_shuffle_epi32(sum, 0xB1)); |
+ |
+ return _mm_cvtsi128_si32(sum); |
+} |
+ |
+inline uint32_t GetVerticalError(const __sse_data* data, |
+ const __m128i* blue_avg, |
+ const __m128i* green_avg, |
+ const __m128i* red_avg, |
+ uint32_t* verror) { |
+ __m128i error = __sse_zero; |
+ |
+ for (int i = 0; i < 4; i++) { |
+ error = _mm_add_epi32(error, GetColorErrorSSE(data->blue[i], blue_avg[0])); |
+ error = |
+ _mm_add_epi32(error, GetColorErrorSSE(data->green[i], green_avg[0])); |
+ error = _mm_add_epi32(error, GetColorErrorSSE(data->red[i], red_avg[0])); |
+ } |
+ |
+ error = _mm_add_epi32(error, _mm_shuffle_epi32(error, 0x4E)); |
+ |
+ verror[0] = _mm_cvtsi128_si32(error); |
+ verror[1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(error, 0xB1)); |
+ |
+ return verror[0] + verror[1]; |
+} |
+ |
+inline uint32_t GetHorizontalError(const __sse_data* data, |
+ const __m128i* blue_avg, |
+ const __m128i* green_avg, |
+ const __m128i* red_avg, |
+ uint32_t* verror) { |
+ __m128i error = __sse_zero; |
+ int first_index, second_index; |
+ |
+ for (int i = 0; i < 2; i++) { |
+ first_index = 2 * i; |
+ second_index = first_index + 1; |
+ |
+ error = _mm_add_epi32( |
+ error, GetColorErrorSSE(data->blue[first_index], blue_avg[i])); |
+ error = _mm_add_epi32( |
+ error, GetColorErrorSSE(data->blue[second_index], blue_avg[i])); |
+ error = _mm_add_epi32( |
+ error, GetColorErrorSSE(data->green[first_index], green_avg[i])); |
+ error = _mm_add_epi32( |
+ error, GetColorErrorSSE(data->green[second_index], green_avg[i])); |
+ error = _mm_add_epi32(error, |
+ GetColorErrorSSE(data->red[first_index], red_avg[i])); |
+ error = _mm_add_epi32( |
+ error, GetColorErrorSSE(data->red[second_index], red_avg[i])); |
+ } |
+ |
+ error = _mm_add_epi32(error, _mm_shuffle_epi32(error, 0x4E)); |
+ |
+ verror[0] = _mm_cvtsi128_si32(error); |
+ verror[1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(error, 0xB1)); |
+ |
+ return verror[0] + verror[1]; |
+} |
+ |
+inline void GetAvgColors(const __sse_data* data, |
+ float* output, |
+ bool* __sse_use_diff) { |
+ __m128i sum[2], tmp; |
+ |
+ // TODO(radu.velea): _mm_avg_epu8 on packed data maybe |
+ |
+ /* get avg red */ |
+ /* [S0 S0 S1 S1] */ |
+ sum[0] = _mm_add_epi32(data->red[0], data->red[1]); |
+ sum[0] = _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0xB1)); |
+ |
+ /* [S2 S2 S3 S3] */ |
+ sum[1] = _mm_add_epi32(data->red[2], data->red[3]); |
+ sum[1] = _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0xB1)); |
+ |
+ float hred[2], vred[2]; |
+ hred[0] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0x4E)))) / |
+ 8.0f; |
+ hred[1] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0x4E)))) / |
+ 8.0f; |
+ |
+ tmp = _mm_add_epi32(sum[0], sum[1]); |
+ vred[0] = (_mm_cvtsi128_si32(tmp)) / 8.0f; |
+ vred[1] = (_mm_cvtsi128_si32(_mm_shuffle_epi32(tmp, 0x2))) / 8.0f; |
+ |
+ /* get avg green */ |
+ /* [S0 S0 S1 S1] */ |
+ sum[0] = _mm_add_epi32(data->green[0], data->green[1]); |
+ sum[0] = _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0xB1)); |
+ |
+ /* [S2 S2 S3 S3] */ |
+ sum[1] = _mm_add_epi32(data->green[2], data->green[3]); |
+ sum[1] = _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0xB1)); |
+ |
+ float hgreen[2], vgreen[2]; |
+ hgreen[0] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0x4E)))) / |
+ 8.0f; |
+ hgreen[1] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0x4E)))) / |
+ 8.0f; |
+ |
+ tmp = _mm_add_epi32(sum[0], sum[1]); |
+ vgreen[0] = (_mm_cvtsi128_si32(tmp)) / 8.0f; |
+ vgreen[1] = (_mm_cvtsi128_si32(_mm_shuffle_epi32(tmp, 0x2))) / 8.0f; |
+ |
+ /* get avg blue */ |
+ /* [S0 S0 S1 S1] */ |
+ sum[0] = _mm_add_epi32(data->blue[0], data->blue[1]); |
+ sum[0] = _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0xB1)); |
+ |
+ /* [S2 S2 S3 S3] */ |
+ sum[1] = _mm_add_epi32(data->blue[2], data->blue[3]); |
+ sum[1] = _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0xB1)); |
+ |
+ float hblue[2], vblue[2]; |
+ hblue[0] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[0], _mm_shuffle_epi32(sum[0], 0x4E)))) / |
+ 8.0f; |
+ hblue[1] = (_mm_cvtsi128_si32( |
+ _mm_add_epi32(sum[1], _mm_shuffle_epi32(sum[1], 0x4E)))) / |
+ 8.0f; |
+ |
+ tmp = _mm_add_epi32(sum[0], sum[1]); |
+ vblue[0] = (_mm_cvtsi128_si32(tmp)) / 8.0f; |
+ vblue[1] = (_mm_cvtsi128_si32(_mm_shuffle_epi32(tmp, 0x2))) / 8.0f; |
+ |
+ /* TODO(radu.velea): return int's instead of floats */ |
+ output[0] = vblue[0]; |
+ output[1] = vgreen[0]; |
+ output[2] = vred[0]; |
+ |
+ output[3] = vblue[1]; |
+ output[4] = vgreen[1]; |
+ output[5] = vred[1]; |
+ |
+ output[6] = hblue[0]; |
+ output[7] = hgreen[0]; |
+ output[8] = hred[0]; |
+ |
+ output[9] = hblue[1]; |
+ output[10] = hgreen[1]; |
+ output[11] = hred[1]; |
+ |
+ __m128i threashhold_upper = _mm_set1_epi32(3); |
robert.bradford
2015/04/28 15:47:04
nit: spelling s/threashold/threshold/g
|
+ __m128i threashhold_lower = _mm_set1_epi32(-4); |
+ |
+ __m128 factor_v = _mm_set1_ps(31.0f / 255.0f); |
+ __m128 rounding_v = _mm_set1_ps(0.5f); |
+ __m128 h_avg_0 = _mm_set_ps(hblue[0], hgreen[0], hred[0], 0); |
+ __m128 h_avg_1 = _mm_set_ps(hblue[1], hgreen[1], hred[1], 0); |
+ |
+ __m128 v_avg_0 = _mm_set_ps(vblue[0], vgreen[0], vred[0], 0); |
+ __m128 v_avg_1 = _mm_set_ps(vblue[1], vgreen[1], vred[1], 0); |
+ |
+ h_avg_0 = _mm_mul_ps(h_avg_0, factor_v); |
+ h_avg_1 = _mm_mul_ps(h_avg_1, factor_v); |
+ v_avg_0 = _mm_mul_ps(v_avg_0, factor_v); |
+ v_avg_1 = _mm_mul_ps(v_avg_1, factor_v); |
+ |
+ h_avg_0 = _mm_add_ps(h_avg_0, rounding_v); |
+ h_avg_1 = _mm_add_ps(h_avg_1, rounding_v); |
+ v_avg_0 = _mm_add_ps(v_avg_0, rounding_v); |
+ v_avg_1 = _mm_add_ps(v_avg_1, rounding_v); |
+ |
+ __m128i h_avg_0i = _mm_cvttps_epi32(h_avg_0); |
+ __m128i h_avg_1i = _mm_cvttps_epi32(h_avg_1); |
+ |
+ __m128i v_avg_0i = _mm_cvttps_epi32(v_avg_0); |
+ __m128i v_avg_1i = _mm_cvttps_epi32(v_avg_1); |
+ |
+ h_avg_0i = _mm_sub_epi32(h_avg_1i, h_avg_0i); |
+ v_avg_0i = _mm_sub_epi32(v_avg_1i, v_avg_0i); |
+ |
+ __sse_use_diff[0] = |
+ (0 == _mm_movemask_epi8(_mm_cmplt_epi32(v_avg_0i, threashhold_lower))); |
+ __sse_use_diff[0] &= |
+ (0 == _mm_movemask_epi8(_mm_cmpgt_epi32(v_avg_0i, threashhold_upper))); |
+ |
+ __sse_use_diff[1] = |
+ (0 == _mm_movemask_epi8(_mm_cmplt_epi32(h_avg_0i, threashhold_lower))); |
+ __sse_use_diff[1] &= |
+ (0 == _mm_movemask_epi8(_mm_cmpgt_epi32(h_avg_0i, threashhold_upper))); |
+} |
+ |
+void ComputeLuminance(uint8_t* block, |
+ const Color& base, |
+ const int sub_block_id, |
+ const uint8_t* idx_to_num_tab, |
+ const __sse_data* data, |
+ const uint32_t expected_error) { |
+ uint8_t best_tbl_idx = 0; |
+ uint32_t best_error = 0x7FFFFFFF; |
+ uint8_t best_mod_idx[8][8]; // [table][texel] |
+ |
+ const __m128i base_blue = _mm_set1_epi32(base.channels.b); |
+ const __m128i base_green = _mm_set1_epi32(base.channels.g); |
+ const __m128i base_red = _mm_set1_epi32(base.channels.r); |
+ |
+ __m128i test_red, test_blue, test_green, tmp, tmp_blue, tmp_green, tmp_red; |
+ __m128i block_error, mask; |
+ |
+ /* this will have the minimum errors for each 4 pixels */ |
+ __m128i first_half_min; |
+ __m128i second_half_min; |
+ |
+ /* this will have the matching table index combo for each 4 pixels */ |
+ __m128i first_half_pattern; |
+ __m128i second_half_pattern; |
+ |
+ const __m128i first_blue_data_block = data->blue[2 * sub_block_id]; |
+ const __m128i first_green_data_block = data->green[2 * sub_block_id]; |
+ const __m128i first_red_data_block = data->red[2 * sub_block_id]; |
+ |
+ const __m128i second_blue_data_block = data->blue[2 * sub_block_id + 1]; |
+ const __m128i second_green_data_block = data->green[2 * sub_block_id + 1]; |
+ const __m128i second_red_data_block = data->red[2 * sub_block_id + 1]; |
+ |
+ uint32_t min; |
+ /* fail early to increase speed */ |
+ long delta = INT32_MAX; |
+ uint32_t last_min = INT32_MAX; |
+ |
+ const uint8_t shuffle_mask[] = { |
+ 0x1B, 0x4E, 0xB1, 0xE4}; /* important they are sorted ascending */ |
+ |
+ for (unsigned int tbl_idx = 0; tbl_idx < 8; ++tbl_idx) { |
+ tmp = _mm_set_epi32( |
+ g_codeword_tables[tbl_idx][3], g_codeword_tables[tbl_idx][2], |
+ g_codeword_tables[tbl_idx][1], g_codeword_tables[tbl_idx][0]); |
+ |
+ test_blue = AddAndClamp(tmp, base_blue); |
+ test_green = AddAndClamp(tmp, base_green); |
+ test_red = AddAndClamp(tmp, base_red); |
+ |
+ first_half_min = __sse_max_int; |
+ second_half_min = __sse_max_int; |
+ |
+ first_half_pattern = __sse_zero; |
+ second_half_pattern = __sse_zero; |
+ |
+ for (uint8_t imm8 : shuffle_mask) { |
+ switch (imm8) { |
+ case 0x1B: |
+ tmp_blue = _mm_shuffle_epi32(test_blue, 0x1B); |
+ tmp_green = _mm_shuffle_epi32(test_green, 0x1B); |
+ tmp_red = _mm_shuffle_epi32(test_red, 0x1B); |
+ break; |
+ case 0x4E: |
+ tmp_blue = _mm_shuffle_epi32(test_blue, 0x4E); |
+ tmp_green = _mm_shuffle_epi32(test_green, 0x4E); |
+ tmp_red = _mm_shuffle_epi32(test_red, 0x4E); |
+ break; |
+ case 0xB1: |
+ tmp_blue = _mm_shuffle_epi32(test_blue, 0xB1); |
+ tmp_green = _mm_shuffle_epi32(test_green, 0xB1); |
+ tmp_red = _mm_shuffle_epi32(test_red, 0xB1); |
+ break; |
+ case 0xE4: |
+ tmp_blue = _mm_shuffle_epi32(test_blue, 0xE4); |
+ tmp_green = _mm_shuffle_epi32(test_green, 0xE4); |
+ tmp_red = _mm_shuffle_epi32(test_red, 0xE4); |
+ break; |
+ default: |
+ tmp_blue = test_blue; |
+ tmp_green = test_green; |
+ tmp_red = test_red; |
+ } |
+ |
+ tmp = _mm_set1_epi32(imm8); |
+ |
+ block_error = |
+ AddChannelError(GetColorErrorSSE(tmp_blue, first_blue_data_block), |
+ GetColorErrorSSE(tmp_green, first_green_data_block), |
+ GetColorErrorSSE(tmp_red, first_red_data_block)); |
+ |
+ /* save winning pattern */ |
+ first_half_pattern = _mm_max_epi16( |
+ first_half_pattern, |
+ _mm_and_si128(tmp, _mm_cmpgt_epi32(first_half_min, block_error))); |
+ /* should use _mm_min_epi32(first_half_min, block_error); otherwise |
+ * performance penalty */ |
+ mask = _mm_cmplt_epi32(block_error, first_half_min); |
+ first_half_min = _mm_add_epi32(_mm_and_si128(mask, block_error), |
+ _mm_andnot_si128(mask, first_half_min)); |
+ |
+ /* Second part of the block */ |
+ block_error = |
+ AddChannelError(GetColorErrorSSE(tmp_blue, second_blue_data_block), |
+ GetColorErrorSSE(tmp_green, second_green_data_block), |
+ GetColorErrorSSE(tmp_red, second_red_data_block)); |
+ |
+ /* save winning pattern */ |
+ second_half_pattern = _mm_max_epi16( |
+ second_half_pattern, |
+ _mm_and_si128(tmp, _mm_cmpgt_epi32(second_half_min, block_error))); |
+ /* should use _mm_min_epi32(second_half_min, block_error); otherwise |
+ * performance penalty */ |
+ mask = _mm_cmplt_epi32(block_error, second_half_min); |
+ second_half_min = _mm_add_epi32(_mm_and_si128(mask, block_error), |
+ _mm_andnot_si128(mask, second_half_min)); |
+ } |
+ |
+ first_half_min = _mm_add_epi32(first_half_min, second_half_min); |
+ first_half_min = |
+ _mm_add_epi32(first_half_min, _mm_shuffle_epi32(first_half_min, 0x4E)); |
+ first_half_min = |
+ _mm_add_epi32(first_half_min, _mm_shuffle_epi32(first_half_min, 0xB1)); |
+ |
+ min = _mm_cvtsi128_si32(first_half_min); |
+ |
+ delta = min - last_min; |
+ last_min = min; |
+ |
+ if (min < best_error) { |
+ best_tbl_idx = tbl_idx; |
+ best_error = min; |
+ |
+ best_mod_idx[tbl_idx][0] = |
+ (_mm_cvtsi128_si32(first_half_pattern) >> (0)) & 3; |
+ best_mod_idx[tbl_idx][4] = |
+ (_mm_cvtsi128_si32(second_half_pattern) >> (0)) & 3; |
+ |
+ best_mod_idx[tbl_idx][1] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(first_half_pattern, 0x1)) >> |
+ (2)) & |
+ 3; |
+ best_mod_idx[tbl_idx][5] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(second_half_pattern, 0x1)) >> |
+ (2)) & |
+ 3; |
+ |
+ best_mod_idx[tbl_idx][2] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(first_half_pattern, 0x2)) >> |
+ (4)) & |
+ 3; |
+ best_mod_idx[tbl_idx][6] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(second_half_pattern, 0x2)) >> |
+ (4)) & |
+ 3; |
+ |
+ best_mod_idx[tbl_idx][3] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(first_half_pattern, 0x3)) >> |
+ (6)) & |
+ 3; |
+ best_mod_idx[tbl_idx][7] = |
+ (_mm_cvtsi128_si32(_mm_shuffle_epi32(second_half_pattern, 0x3)) >> |
+ (6)) & |
+ 3; |
+ |
+ if (best_error == 0) { |
+ break; |
+ } |
+ } else if (delta > 0 && expected_error < min) { |
+ /* error is growing and is well beyond expected error */ |
+ break; |
+ } |
+ } |
+ |
+ WriteCodewordTable(block, sub_block_id, best_tbl_idx); |
+ |
+ uint32_t pix_data = 0; |
+ uint8_t mod_idx; |
+ uint8_t pix_idx; |
+ uint32_t lsb; |
+ uint32_t msb; |
+ int texel_num; |
+ |
+ for (unsigned int i = 0; i < 8; ++i) { |
+ mod_idx = best_mod_idx[best_tbl_idx][i]; |
+ pix_idx = g_mod_to_pix[mod_idx]; |
+ |
+ lsb = pix_idx & 0x1; |
+ msb = pix_idx >> 1; |
+ |
+ // Obtain the texel number as specified in the standard. |
+ texel_num = idx_to_num_tab[i]; |
+ pix_data |= msb << (texel_num + 16); |
+ pix_data |= lsb << (texel_num); |
+ } |
+ |
+ WritePixelData(block, pix_data); |
+} |
+ |
+void CompressBlock(uint8_t* dst, __sse_data* data) { |
+ /* first 3 vertical 1, seconds 3 vertical 2, third 3 horizontal 1, last 3 |
+ * horizontal 2 */ |
+ float __sse_avg_colors[12] = { |
+ 0, |
+ }; |
+ bool use_differential[2] = {true, true}; |
+ GetAvgColors(data, __sse_avg_colors, use_differential); |
+ Color sub_block_avg[4]; |
+ |
+ /* TODO(radu.velea): remove floating point operations and use only int's + |
+ * normal |
+ * rounding and shifts */ |
+ for (int i = 0, j = 1; i < 4; i += 2, j += 2) { |
+ if (use_differential[i / 2] == false) { |
+ sub_block_avg[i] = MakeColor444(&__sse_avg_colors[i * 3]); |
+ sub_block_avg[j] = MakeColor444(&__sse_avg_colors[j * 3]); |
+ } else { |
+ sub_block_avg[i] = MakeColor555(&__sse_avg_colors[i * 3]); |
+ sub_block_avg[j] = MakeColor555(&__sse_avg_colors[j * 3]); |
+ } |
+ } |
+ |
+ __m128i red_avg[2], green_avg[2], blue_avg[2]; |
+ |
+ // TODO(radu.velea): perfect accuracy, maybe skip floating variables |
+ blue_avg[0] = |
+ _mm_set_epi32((int)__sse_avg_colors[3], (int)__sse_avg_colors[3], |
+ (int)__sse_avg_colors[0], (int)__sse_avg_colors[0]); |
+ |
+ green_avg[0] = |
+ _mm_set_epi32((int)__sse_avg_colors[4], (int)__sse_avg_colors[4], |
+ (int)__sse_avg_colors[1], (int)__sse_avg_colors[1]); |
+ |
+ red_avg[0] = |
+ _mm_set_epi32((int)__sse_avg_colors[5], (int)__sse_avg_colors[5], |
+ (int)__sse_avg_colors[2], (int)__sse_avg_colors[2]); |
+ |
+ uint32_t vertical_error[2]; |
+ GetVerticalError(data, blue_avg, green_avg, red_avg, vertical_error); |
+ |
+ // TODO(radu.velea): perfect accuracy, maybe skip floating variables |
+ blue_avg[0] = _mm_set1_epi32((int)__sse_avg_colors[6]); |
+ blue_avg[1] = _mm_set1_epi32((int)__sse_avg_colors[9]); |
+ |
+ green_avg[0] = _mm_set1_epi32((int)__sse_avg_colors[7]); |
+ green_avg[1] = _mm_set1_epi32((int)__sse_avg_colors[10]); |
+ |
+ red_avg[0] = _mm_set1_epi32((int)__sse_avg_colors[8]); |
+ red_avg[1] = _mm_set1_epi32((int)__sse_avg_colors[11]); |
+ |
+ uint32_t horizontal_error[2]; |
+ GetHorizontalError(data, blue_avg, green_avg, red_avg, horizontal_error); |
+ |
+ bool flip = (horizontal_error[0] + horizontal_error[1]) < |
+ (vertical_error[0] + vertical_error[1]); |
+ uint32_t* expected_errors = flip == true ? horizontal_error : vertical_error; |
+ |
+ // Clear destination buffer so that we can "or" in the results. |
+ memset(dst, 0, 8); |
+ |
+ WriteDiff(dst, use_differential[!!flip]); |
+ WriteFlip(dst, flip); |
+ |
+ uint8_t sub_block_off_0 = flip ? 2 : 0; |
+ uint8_t sub_block_off_1 = sub_block_off_0 + 1; |
+ |
+ if (use_differential[!!flip]) { |
+ WriteColors555(dst, sub_block_avg[sub_block_off_0], |
+ sub_block_avg[sub_block_off_1]); |
+ } else { |
+ WriteColors444(dst, sub_block_avg[sub_block_off_0], |
+ sub_block_avg[sub_block_off_1]); |
+ } |
+ |
+ if (flip == false) { |
+ /* transpose vertical data into horizontal lines */ |
+ __m128i tmp; |
+ for (int i = 0; i < 4; i += 2) { |
+ tmp = data->blue[i]; |
+ data->blue[i] = _mm_add_epi32( |
+ _mm_move_epi64(data->blue[i]), |
+ _mm_shuffle_epi32(_mm_move_epi64(data->blue[i + 1]), 0x4E)); |
+ data->blue[i + 1] = _mm_add_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(tmp, 0x4E)), |
+ _mm_shuffle_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(data->blue[i + 1], 0x4E)), |
+ 0x4E)); |
+ |
+ tmp = data->green[i]; |
+ data->green[i] = _mm_add_epi32( |
+ _mm_move_epi64(data->green[i]), |
+ _mm_shuffle_epi32(_mm_move_epi64(data->green[i + 1]), 0x4E)); |
+ data->green[i + 1] = _mm_add_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(tmp, 0x4E)), |
+ _mm_shuffle_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(data->green[i + 1], 0x4E)), |
+ 0x4E)); |
+ |
+ tmp = data->red[i]; |
+ data->red[i] = _mm_add_epi32( |
+ _mm_move_epi64(data->red[i]), |
+ _mm_shuffle_epi32(_mm_move_epi64(data->red[i + 1]), 0x4E)); |
+ data->red[i + 1] = _mm_add_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(tmp, 0x4E)), |
+ _mm_shuffle_epi32( |
+ _mm_move_epi64(_mm_shuffle_epi32(data->red[i + 1], 0x4E)), 0x4E)); |
+ } |
+ |
+ tmp = data->blue[1]; |
+ data->blue[1] = data->blue[2]; |
+ data->blue[2] = tmp; |
+ |
+ tmp = data->green[1]; |
+ data->green[1] = data->green[2]; |
+ data->green[2] = tmp; |
+ |
+ tmp = data->red[1]; |
+ data->red[1] = data->red[2]; |
+ data->red[2] = tmp; |
+ } |
+ |
+ // Compute luminance for the first sub block. |
+ ComputeLuminance(dst, sub_block_avg[sub_block_off_0], 0, |
+ g_idx_to_num[sub_block_off_0], data, |
+ ETC1_SET_ERROR(expected_errors[0])); |
+ // Compute luminance for the second sub block. |
+ ComputeLuminance(dst, sub_block_avg[sub_block_off_1], 1, |
+ g_idx_to_num[sub_block_off_1], data, |
+ ETC1_SET_ERROR(expected_errors[1])); |
+} |
+ |
+static void ExtractBlock(uint8_t* dst, const uint8_t* src, int width) { |
+ for (int j = 0; j < 4; ++j) { |
+ memcpy(&dst[j * 4 * 4], src, 4 * 4); |
+ src += width * 4; |
+ } |
+} |
+ |
+inline bool TransposeBlock(uint8_t* block, __m128i* transposed /* [4] */) { |
+ __m128i tmp3, tmp2, tmp1, tmp0; |
+ __m128i test_solid = _mm_set1_epi32(*((uint32_t*)block)); |
+ uint16_t mask = 0xFFFF; |
+ |
+ transposed[0] = _mm_loadu_si128((__m128i*)(block)); // a0,a1,a2,...a7, ...a15 |
+ transposed[1] = |
+ _mm_loadu_si128((__m128i*)(block + 16)); // b0, b1,b2,...b7.... b15 |
+ transposed[2] = |
+ _mm_loadu_si128((__m128i*)(block + 32)); // c0, c1,c2,...c7....c15 |
+ transposed[3] = |
+ _mm_loadu_si128((__m128i*)(block + 48)); // d0,d1,d2,...d7....d15 |
+ |
+ for (int i = 0; i < 4; i++) { |
+ mask &= _mm_movemask_epi8(_mm_cmpeq_epi8(transposed[i], test_solid)); |
+ } |
+ |
+ if (mask == 0xFFFF) { |
+ return false; /* block is solid, no need to do any more work */ |
+ } |
+ |
+ tmp0 = _mm_unpacklo_epi8( |
+ transposed[0], transposed[1]); // a0,b0, a1,b1, a2,b2, a3,b3,....a7,b7 |
+ tmp1 = _mm_unpacklo_epi8( |
+ transposed[2], transposed[3]); // c0,d0, c1,d1, c2,d2, c3,d3,... c7,d7 |
+ tmp2 = _mm_unpackhi_epi8( |
+ transposed[0], |
+ transposed[1]); // a8,b8, a9,b9, a10,b10, a11,b11,...a15,b15 |
+ tmp3 = _mm_unpackhi_epi8( |
+ transposed[2], |
+ transposed[3]); // c8,d8, c9,d9, c10,d10, c11,d11,...c15,d15 |
+ |
+ transposed[0] = _mm_unpacklo_epi8( |
+ tmp0, tmp2); // a0,a8, b0,b8, a1,a9, b1,b9, ....a3,a11, b3,b11 |
+ transposed[1] = _mm_unpackhi_epi8( |
+ tmp0, tmp2); // a4,a12, b4,b12, a5,a13, b5,b13,....a7,a15,b7,b15 |
+ transposed[2] = |
+ _mm_unpacklo_epi8(tmp1, tmp3); // c0,c8, d0,d8, c1,c9, d1,d9.....d3,d11 |
+ transposed[3] = _mm_unpackhi_epi8( |
+ tmp1, tmp3); // c4,c12,d4,d12, c5,c13, d5,d13,....d7,d15 |
+ |
+ tmp0 = _mm_unpacklo_epi32(transposed[0], transposed[2]); // a0,a8, b0,b8, |
+ // c0,c8, d0,d8, |
+ // a1,a9, b1,b9, |
+ // c1,c9, d1,d9 |
+ tmp1 = _mm_unpackhi_epi32(transposed[0], transposed[2]); // a2,a10, b2,b10, |
+ // c2,c10, d2,d10, |
+ // a3,a11, b3,b11, |
+ // c3,c11, d3,d11 |
+ tmp2 = _mm_unpacklo_epi32(transposed[1], transposed[3]); // a4,a12, b4,b12, |
+ // c4,c12, d4,d12, |
+ // a5,a13, b5,b13, |
+ // c5,c13, d5,d13, |
+ tmp3 = _mm_unpackhi_epi32(transposed[1], |
+ transposed[3]); // a6,a14, b6,b14, c6,c14, d6,d14, |
+ // a7,a15,b7,b15,c7,c15,d7,d15 |
+ |
+ transposed[0] = _mm_unpacklo_epi8(tmp0, tmp2); // a0,a4, a8, a12, b0,b4, |
+ // b8,b12, c0,c4, c8, c12, |
+ // d0,d4, d8, d12 |
+ transposed[1] = _mm_unpackhi_epi8(tmp0, tmp2); // a1,a5, a9, a13, b1,b5, |
+ // b9,b13, c1,c5, c9, c13, |
+ // d1,d5, d9, d13 |
+ transposed[2] = _mm_unpacklo_epi8(tmp1, tmp3); // a2,a6, a10,a14, b2,b6, |
+ // b10,b14, c2,c6, c10,c14, |
+ // d2,d6, d10,d14 |
+ transposed[3] = _mm_unpackhi_epi8(tmp1, tmp3); // a3,a7, a11,a15, b3,b7, |
+ // b11,b15, c3,c7, c11,c15, |
+ // d3,d7, d11,d15 |
+ return true; |
+} |
+ |
+inline void UnpackBlock(__m128i* packed, |
+ __m128i* red, |
+ __m128i* green, |
+ __m128i* blue, |
+ __m128i* alpha) { |
+ const __m128i zero = _mm_set1_epi8(0); |
+ __m128i tmp_low, tmp_high; |
+ |
+ /* unpack red */ |
+ tmp_low = _mm_unpacklo_epi8(packed[0], zero); |
+ tmp_high = _mm_unpackhi_epi8(packed[0], zero); |
+ |
+ red[0] = _mm_unpacklo_epi16(tmp_low, zero); |
+ red[1] = _mm_unpackhi_epi16(tmp_low, zero); |
+ |
+ red[2] = _mm_unpacklo_epi16(tmp_high, zero); |
+ red[3] = _mm_unpackhi_epi16(tmp_high, zero); |
+ |
+ /* unpack green */ |
+ tmp_low = _mm_unpacklo_epi8(packed[1], zero); |
+ tmp_high = _mm_unpackhi_epi8(packed[1], zero); |
+ |
+ green[0] = _mm_unpacklo_epi16(tmp_low, zero); |
+ green[1] = _mm_unpackhi_epi16(tmp_low, zero); |
+ |
+ green[2] = _mm_unpacklo_epi16(tmp_high, zero); |
+ green[3] = _mm_unpackhi_epi16(tmp_high, zero); |
+ |
+ /* unpack blue */ |
+ tmp_low = _mm_unpacklo_epi8(packed[2], zero); |
+ tmp_high = _mm_unpackhi_epi8(packed[2], zero); |
+ |
+ blue[0] = _mm_unpacklo_epi16(tmp_low, zero); |
+ blue[1] = _mm_unpackhi_epi16(tmp_low, zero); |
+ |
+ blue[2] = _mm_unpacklo_epi16(tmp_high, zero); |
+ blue[3] = _mm_unpackhi_epi16(tmp_high, zero); |
+ |
+ /* unpack alpha */ |
+ tmp_low = _mm_unpacklo_epi8(packed[3], zero); |
+ tmp_high = _mm_unpackhi_epi8(packed[3], zero); |
+ |
+ alpha[0] = _mm_unpacklo_epi16(tmp_low, zero); |
+ alpha[1] = _mm_unpackhi_epi16(tmp_low, zero); |
+ |
+ alpha[2] = _mm_unpacklo_epi16(tmp_high, zero); |
+ alpha[3] = _mm_unpackhi_epi16(tmp_high, zero); |
+} |
+ |
+inline void CompressSolid(uint8_t* dst, uint8_t* block) { |
+ // Clear destination buffer so that we can "or" in the results. |
+ memset(dst, 0, 8); |
+ |
+ const float src_color_float[3] = {static_cast<float>(block[0]), |
+ static_cast<float>(block[1]), |
+ static_cast<float>(block[2])}; |
+ const Color base = MakeColor555(src_color_float); |
+ const __m128i base_v = |
+ _mm_set_epi32(0, base.channels.r, base.channels.g, base.channels.b); |
+ |
+ const __m128i constant = _mm_set_epi32(0, block[2], block[1], block[0]); |
+ __m128i lum; |
+ __m128i colors[4]; |
+ static const __m128i rgb = |
+ _mm_set_epi32(0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); |
+ |
+ WriteDiff(dst, true); |
+ WriteFlip(dst, false); |
+ |
+ WriteColors555(dst, base, base); |
+ |
+ uint8_t best_tbl_idx = 0; |
+ uint8_t best_mod_idx = 0; |
+ uint32_t best_mod_err = INT32_MAX; |
+ |
+ for (unsigned int tbl_idx = 0; tbl_idx < 8; ++tbl_idx) { |
+ lum = _mm_set_epi32( |
+ g_codeword_tables[tbl_idx][3], g_codeword_tables[tbl_idx][2], |
+ g_codeword_tables[tbl_idx][1], g_codeword_tables[tbl_idx][0]); |
+ colors[0] = AddAndClamp(base_v, _mm_shuffle_epi32(lum, 0x0)); |
+ colors[1] = AddAndClamp(base_v, _mm_shuffle_epi32(lum, 0x55)); |
+ colors[2] = AddAndClamp(base_v, _mm_shuffle_epi32(lum, 0xAA)); |
+ colors[3] = AddAndClamp(base_v, _mm_shuffle_epi32(lum, 0xFF)); |
+ |
+ for (int i = 0; i < 4; i++) { |
+ uint32_t mod_err = |
+ SumSSE(GetColorErrorSSE(constant, _mm_and_si128(colors[i], rgb))); |
+ colors[i] = _mm_and_si128(colors[i], rgb); |
+ if (mod_err < best_mod_err) { |
+ best_tbl_idx = tbl_idx; |
+ best_mod_idx = i; |
+ best_mod_err = mod_err; |
+ |
+ if (mod_err == 0) { |
+ break; // We cannot do any better than this. |
+ } |
+ } |
+ } |
+ } |
+ |
+ WriteCodewordTable(dst, 0, best_tbl_idx); |
+ WriteCodewordTable(dst, 1, best_tbl_idx); |
+ |
+ uint8_t pix_idx = g_mod_to_pix[best_mod_idx]; |
+ uint32_t lsb = pix_idx & 0x1; |
+ uint32_t msb = pix_idx >> 1; |
+ |
+ uint32_t pix_data = 0; |
+ for (unsigned int i = 0; i < 2; ++i) { |
+ for (unsigned int j = 0; j < 8; ++j) { |
+ // Obtain the texel number as specified in the standard. |
+ int texel_num = g_idx_to_num[i][j]; |
+ pix_data |= msb << (texel_num + 16); |
+ pix_data |= lsb << (texel_num); |
+ } |
+ } |
+ |
+ WritePixelData(dst, pix_data); |
+} |
+ |
+} // namespace |
+ |
+namespace cc { |
+ |
+void TextureCompressorETC1SSE::Compress(const uint8_t* src, |
+ uint8_t* dst, |
+ int width, |
+ int height, |
+ Quality quality) { |
+ DCHECK(width >= 4 && (width & 3) == 0); |
+ DCHECK(height >= 4 && (height & 3) == 0); |
+ |
+ ALIGNAS(16) uint8_t block[64]; |
+ __m128i packed[4]; |
+ __m128i red[4], green[4], blue[4], alpha[4]; |
+ __sse_data data; |
+ |
+ for (int y = 0; y < height; y += 4, src += width * 4 * 4) { |
+ for (int x = 0; x < width; x += 4, dst += 8) { |
+ ExtractBlock(block, src + x * 4, width); |
+ if (TransposeBlock(block, packed) == false) { |
+ CompressSolid(dst, block); |
+ } else { |
+ UnpackBlock(packed, blue, green, red, alpha); |
+ |
+ data.block = block; |
+ data.packed = packed; |
+ data.red = red; |
+ data.blue = blue; |
+ data.green = green; |
+ |
+ CompressBlock(dst, &data); |
+ } |
+ } |
+ } |
+} |
+ |
+} // namespace cc |