Reland: Add ETC1 powered SSE encoder for tile texture compression

cc/resources/texture_compressor_etc1_sse.cc

+// 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 <smmintrin.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <cmath>
+#include <limits>
+#include <sstream>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+
+// Defining the following macro will cause the error metric function to weigh
+// each color channel differently depending on how the human eye can perceive
+// them. This can give a slight improvement in image quality at the cost of a
+// performance hit.
+// #define USE_PERCEIVED_ERROR_METRIC
+
+namespace {
+
+template <typename T>
+inline T clamp(T val, T min, T max) {
+  return val < min ? min : (val > max ? max : val);
+}
+
+inline uint8_t round_to_5_bits(float val) {
+  return clamp<uint8_t>(val * 31.0f / 255.0f + 0.5f, 0, 31);
+}
+
+inline uint8_t round_to_4_bits(float val) {
+  return clamp<uint8_t>(val * 15.0f / 255.0f + 0.5f, 0, 15);
+}
+
+union Color {
+  struct BgraColorType {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t a;
+  } channels;
+  uint8_t components[4];
+  uint32_t bits;
+};
+
+/*
+ * Codeword tables.
+ * See: Table 3.17.2
+ */
+static const int16_t g_codeword_tables[8][4]
+    __attribute__((aligned(16))) = {{-8, -2, 2, 8},
+                                    {-17, -5, 5, 17},
+                                    {-29, -9, 9, 29},
+                                    {-42, -13, 13, 42},
+                                    {-60, -18, 18, 60},
+                                    {-80, -24, 24, 80},
+                                    {-106, -33, 33, 106},
+                                    {-183, -47, 47, 183}};
+
+/*
+ * Maps modifier indices to pixel index values.
+ * See: Table 3.17.3
+ */
+static const uint8_t g_mod_to_pix[4] = {3, 2, 0, 1};
+
+/*
+ * The ETC1 specification index texels as follows:
+ *
+ * [a][e][i][m]     [ 0][ 4][ 8][12]
+ * [b][f][j][n] <-> [ 1][ 5][ 9][13]
+ * [c][g][k][o]     [ 2][ 6][10][14]
+ * [d][h][l][p]     [ 3][ 7][11][15]
+ *
+ * However, when extracting sub blocks from BGRA data the natural array
+ * indexing order ends up different:
+ *
+ * vertical0: [a][e][b][f]  horizontal0: [a][e][i][m]
+ *            [c][g][d][h]               [b][f][j][n]
+ * vertical1: [i][m][j][n]  horizontal1: [c][g][k][o]
+ *            [k][o][l][p]               [d][h][l][p]
+ *
+ * In order to translate from the natural array indices in a sub block to the
+ * indices (number) used by specification and hardware we use this table.
+ */
+static const uint8_t g_idx_to_num[4][8] = {
+    {0, 4, 1, 5, 2, 6, 3, 7},        // Vertical block 0.
+    {8, 12, 9, 13, 10, 14, 11, 15},  // Vertical block 1.
+    {0, 4, 8, 12, 1, 5, 9, 13},      // Horizontal block 0.
+    {2, 6, 10, 14, 3, 7, 11, 15}     // Horizontal block 1.
+};
+
+inline void WriteColors444(uint8_t* block,
+                           const Color& color0,
+                           const Color& color1) {
+  /* 0, 1, 2 - for ARM */

[adrian.belgun, 2015/04/17 14:02:58]

Please check image channel order for input. 
This is more likely an input issue of RGB vs BGR than an endianness one.
Also, for clarity, I recommend changing the assignment from block[2,1,0] =
channels[r,g,b] to block[0,1,2] = channels[b,g,r].

+  block[2] = (color0.channels.r & 0xf0) | (color1.channels.r >> 4);
+  block[1] = (color0.channels.g & 0xf0) | (color1.channels.g >> 4);
+  block[0] = (color0.channels.b & 0xf0) | (color1.channels.b >> 4);
+}
+
+inline void WriteColors555(uint8_t* block,
+                           const Color& color0,
+                           const Color& color1) {
+  // Table for conversion to 3-bit two complement format.
+  static const uint8_t two_compl_trans_table[8] = {
+      4,  // -4 (100b)
+      5,  // -3 (101b)
+      6,  // -2 (110b)
+      7,  // -1 (111b)
+      0,  //  0 (000b)
+      1,  //  1 (001b)
+      2,  //  2 (010b)
+      3,  //  3 (011b)
+  };
+
+  int16_t delta_r =
+      static_cast<int16_t>(color1.channels.r >> 3) - (color0.channels.r >> 3);
+  int16_t delta_g =
+      static_cast<int16_t>(color1.channels.g >> 3) - (color0.channels.g >> 3);
+  int16_t delta_b =
+      static_cast<int16_t>(color1.channels.b >> 3) - (color0.channels.b >> 3);
+  DCHECK(delta_r >= -4 && delta_r <= 3);
+  DCHECK(delta_g >= -4 && delta_g <= 3);
+  DCHECK(delta_b >= -4 && delta_b <= 3);
+
+  /* 0, 1, 2 - for ARM */

[adrian.belgun, 2015/04/17 14:02:58]

Same comments as for :103.

+  block[2] = (color0.channels.r & 0xf8) | two_compl_trans_table[delta_r + 4];
+  block[1] = (color0.channels.g & 0xf8) | two_compl_trans_table[delta_g + 4];
+  block[0] = (color0.channels.b & 0xf8) | two_compl_trans_table[delta_b + 4];
+}
+
+inline void WriteCodewordTable(uint8_t* block,
+                               uint8_t sub_block_id,
+                               uint8_t table) {
+  DCHECK_LT(sub_block_id, 2);
+  DCHECK_LT(table, 8);
+
+  uint8_t shift = (2 + (3 - sub_block_id * 3));
+  block[3] &= ~(0x07 << shift);
+  block[3] |= table << shift;
+}
+
+inline void WritePixelData(uint8_t* block, uint32_t pixel_data) {
+  block[4] |= pixel_data >> 24;
+  block[5] |= (pixel_data >> 16) & 0xff;
+  block[6] |= (pixel_data >> 8) & 0xff;
+  block[7] |= pixel_data & 0xff;
+}
+
+inline void WriteFlip(uint8_t* block, bool flip) {
+  block[3] &= ~0x01;
+  block[3] |= static_cast<uint8_t>(flip);
+}
+
+inline void WriteDiff(uint8_t* block, bool diff) {
+  block[3] &= ~0x02;
+  block[3] |= static_cast<uint8_t>(diff) << 1;
+}
+
+/**
+ * Compress and rounds BGR888 into BGR444. The resulting BGR444 color is
+ * expanded to BGR888 as it would be in hardware after decompression. The
+ * actual 444-bit data is available in the four most significant bits of each
+ * channel.
+ */
+inline Color MakeColor444(const float* bgr) {
+  uint8_t b4 = round_to_4_bits(bgr[0]);
+  uint8_t g4 = round_to_4_bits(bgr[1]);
+  uint8_t r4 = round_to_4_bits(bgr[2]);
+  Color bgr444;
+  bgr444.channels.b = (b4 << 4) | b4;
+  bgr444.channels.g = (g4 << 4) | g4;
+  bgr444.channels.r = (r4 << 4) | r4;
+  bgr444.channels.a = 0x44; /* added by Radu */
+  return bgr444;
+}
+
+/**
+ * Compress and rounds BGR888 into BGR555. The resulting BGR555 color is
+ * expanded to BGR888 as it would be in hardware after decompression. The
+ * actual 555-bit data is available in the five most significant bits of each
+ * channel.
+ */
+inline Color MakeColor555(const float* bgr) {
+  uint8_t b5 = round_to_5_bits(bgr[0]);
+  uint8_t g5 = round_to_5_bits(bgr[1]);
+  uint8_t r5 = round_to_5_bits(bgr[2]);
+  Color bgr555;
+  bgr555.channels.b = (b5 << 3) | (b5 >> 2);
+  bgr555.channels.g = (g5 << 3) | (g5 >> 2);
+  bgr555.channels.r = (r5 << 3) | (r5 >> 2);
+  bgr555.channels.a = 0x55; /* added by Radu */
+  return bgr555;
+}
+
+/**
+ * Constructs a color from a given base color and luminance value.
+ */
+inline Color MakeColor(const Color& base, int16_t lum) {
+  int b = static_cast<int>(base.channels.b) + lum;
+  int g = static_cast<int>(base.channels.g) + lum;
+  int r = static_cast<int>(base.channels.r) + lum;
+  Color color;
+  color.channels.b = static_cast<uint8_t>(clamp(b, 0, 255));
+  color.channels.g = static_cast<uint8_t>(clamp(g, 0, 255));
+  color.channels.r = static_cast<uint8_t>(clamp(r, 0, 255));
+  return color;
+}
+
+/**
+ * Calculates the error metric for two colors. A small error signals that the
+ * colors are similar to each other, a large error the signals the opposite.
+ */
+inline uint32_t GetColorError(const Color& u, const Color& v) {
+#ifdef USE_PERCEIVED_ERROR_METRIC
+  float delta_b = static_cast<float>(u.channels.b) - v.channels.b;
+  float delta_g = static_cast<float>(u.channels.g) - v.channels.g;
+  float delta_r = static_cast<float>(u.channels.r) - v.channels.r;
+  return static_cast<uint32_t>(0.299f * delta_b * delta_b +
+                               0.587f * delta_g * delta_g +
+                               0.114f * delta_r * delta_r);
+#else
+  int delta_b = static_cast<int>(u.channels.b) - v.channels.b;
+  int delta_g = static_cast<int>(u.channels.g) - v.channels.g;
+  int delta_r = static_cast<int>(u.channels.r) - v.channels.r;
+  return delta_b * delta_b + delta_g * delta_g + delta_r * delta_r;
+#endif
+}
+
+/**************************************** START OF SSE CODE

[adrian.belgun, 2015/04/17 14:02:58]

Use only one line here. Reduce number of stars.

+ * ***************************************/
+
+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_epi32(__sse_zero,
+                       _mm_min_epi32(_mm_add_epi32(x, y), color_max));
+}
+
+inline __m128i GetColorErrorSSE(const __m128i x, const __m128i y) {
+  __m128i ret = _mm_sub_epi32(x, y);
+  return _mm_mullo_epi32(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 void ShuffleImm(__m128i *src, __m128i *dest, int size, uint8_t notimm) {
+        switch(notimm) {
+        case 0x1B:
+                for (int i = 0; i < size; i++) {

[adrian.belgun, 2015/04/17 14:02:58]

Braces are optional for single-statement loops. Consider removing them for
increased readability.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Loops_and_Swi...

+                        dest[i] = _mm_shuffle_epi32(src[i], 0x1B);
+                }
+                break;
+        case 0x4E:
+                for (int i = 0; i < size; i++) {
+                        dest[i] = _mm_shuffle_epi32(src[i], 0x4E);
+                }
+                break;
+        case 0xB1:
+                for (int i = 0; i < size; i++) {
+                        dest[i] = _mm_shuffle_epi32(src[i], 0xB1);
+                }
+                break;
+        case 0xE4:
+                for (int i = 0; i < size; i++) {
+                        dest[i] = _mm_shuffle_epi32(src[i], 0xE4);
+                }
+                break;
+        default:
+                for (int i = 0; i < size; i++) {
+                        dest[i] = src[i];
+                }
+        };
+}
+*/
+inline uint32_t GetVerticalError(const __sse_data* data,
+                                 const __m128i* blue_avg,
+                                 const __m128i* green_avg,
+                                 const __m128i* red_avg) {
+  __m128i error = __sse_zero;
+
+#pragma unroll
+  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));
+  error = _mm_add_epi32(error, _mm_shuffle_epi32(error, 0xB1));
+
+  return _mm_cvtsi128_si32(error);
+}
+
+inline uint32_t GetHorizontalError(const __sse_data* data,
+                                   const __m128i* blue_avg,
+                                   const __m128i* green_avg,
+                                   const __m128i* red_avg) {
+  __m128i error = __sse_zero;
+  int first_index, second_index;
+
+#pragma unroll
+  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));
+  error = _mm_add_epi32(error, _mm_shuffle_epi32(error, 0xB1));
+  return _mm_cvtsi128_si32(error);
+}
+
+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_extract_epi32(tmp, 2)) / 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_extract_epi32(tmp, 2)) / 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_extract_epi32(tmp, 2)) / 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);
+  __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 ComputeLuminanceSSE(uint8_t* block,
+                         const Color& base,
+                         const int sub_block_id,
+                         const uint8_t* idx_to_num_tab,
+                         const __sse_data* data) {
+  uint8_t my_best_tbl_idx = 0;
+  uint32_t my_best_error = 0x7FFFFFFF;
+  uint8_t my_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;
+
+  /* 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;
+
+#define ELEMENT_1 3, 2, 1, 0
+#define ELEMENT_2 7, 6, 5, 4
+#define ELEMENT_3 11, 10, 9, 8
+#define ELEMENT_4 15, 14, 13, 12
+
+  static const __m128i mask_extended[4] = {
+      _mm_set_epi8(ELEMENT_1, ELEMENT_2, ELEMENT_3, ELEMENT_4),
+      _mm_set_epi8(ELEMENT_2, ELEMENT_1, ELEMENT_4, ELEMENT_3),
+      _mm_set_epi8(ELEMENT_3, ELEMENT_4, ELEMENT_1, ELEMENT_2),
+      _mm_set_epi8(ELEMENT_4, ELEMENT_3, ELEMENT_2, ELEMENT_1)};
+
+  static const __m128i mask_imm[4] = {_mm_set1_epi32(0x1B),
+                                      _mm_set1_epi32(0x4E),
+                                      _mm_set1_epi32(0xB1),
+                                      _mm_set1_epi32(0xE4)};
+
+  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;
+
+#pragma unroll
+    for (int i = 0; i < 4; i++) {
+      tmp_blue = _mm_shuffle_epi8(test_blue, mask_extended[i]);
+      tmp_green = _mm_shuffle_epi8(test_green, mask_extended[i]);
+      tmp_red = _mm_shuffle_epi8(test_red, mask_extended[i]);
+
+      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_epi32(
+          first_half_pattern,
+          _mm_and_si128(mask_imm[i],
+                        _mm_cmpgt_epi32(first_half_min, block_error)));
+      first_half_min = _mm_min_epi32(first_half_min, block_error);
+
+      /* 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_epi32(
+          second_half_pattern,
+          _mm_and_si128(mask_imm[i],
+                        _mm_cmpgt_epi32(second_half_min, block_error)));
+      second_half_min = _mm_min_epi32(second_half_min, block_error);
+    }
+
+    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);
+
+    if (min < my_best_error) {
+      my_best_tbl_idx = tbl_idx;
+      my_best_error = min;
+#if O3_OPTIMIZATION
+#pragma unroll
+      for (int i = 0; i < 4; i++) {
+        my_best_mod_idx[tbl_idx][i] =
+            (_mm_extract_epi32(first_half_pattern, i) >> (2 * i)) & 3;
+        my_best_mod_idx[tbl_idx][i + 4] =
+            (_mm_extract_epi32(second_half_pattern, i) >> (2 * i)) & 3;
+      }
+#endif
+      my_best_mod_idx[tbl_idx][0] =
+          (_mm_extract_epi32(first_half_pattern, 0) >> (0)) & 3;
+      my_best_mod_idx[tbl_idx][4] =
+          (_mm_extract_epi32(second_half_pattern, 0) >> (0)) & 3;
+
+      my_best_mod_idx[tbl_idx][1] =
+          (_mm_extract_epi32(first_half_pattern, 1) >> (2)) & 3;
+      my_best_mod_idx[tbl_idx][5] =
+          (_mm_extract_epi32(second_half_pattern, 1) >> (2)) & 3;
+
+      my_best_mod_idx[tbl_idx][2] =
+          (_mm_extract_epi32(first_half_pattern, 2) >> (4)) & 3;
+      my_best_mod_idx[tbl_idx][6] =
+          (_mm_extract_epi32(second_half_pattern, 2) >> (4)) & 3;
+
+      my_best_mod_idx[tbl_idx][3] =
+          (_mm_extract_epi32(first_half_pattern, 3) >> (6)) & 3;
+      my_best_mod_idx[tbl_idx][7] =
+          (_mm_extract_epi32(second_half_pattern, 3) >> (6)) & 3;
+
+      if (my_best_error == 0) {
+        break;
+      }
+    }
+  }
+
+  WriteCodewordTable(block, sub_block_id, my_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 = my_best_mod_idx[my_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 =
+      GetVerticalError(data, blue_avg, green_avg, red_avg);
+
+  // 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 =
+      GetHorizontalError(data, blue_avg, green_avg, red_avg);
+
+  bool flip = 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;
+#pragma unroll
+    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.
+  ComputeLuminanceSSE(dst, sub_block_avg[sub_block_off_0], 0,
+                      g_idx_to_num[sub_block_off_0], data);
+  // Compute luminance for the second sub block.
+  ComputeLuminanceSSE(dst, sub_block_avg[sub_block_off_1], 1,
+                      g_idx_to_num[sub_block_off_1], data);
+}
+
+static void LegacyExtractBlock(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 void TransposeBlock(uint8_t* block, __m128i* transposed /* [4] */) {
+  __m128i tmp3, tmp2, tmp1, tmp0;
+

[adrian.belgun, 2015/04/17 14:02:58]

I think something went wrong with 'git cl format' in this function. Please
review your comments in the source file.

+  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
+
+  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
+}
+
+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 int BlockIsConstant(const uint8_t* block, const __m128i* transposed) {
+  __m128i first = _mm_set1_epi8(block[0]);
+  first = _mm_cmpeq_epi8(transposed[0], first);
+  if (_mm_movemask_epi8(first) != 0xFFFF) {
+    return 0;
+  }
+
+  first = _mm_set1_epi8(block[1]);
+  first = _mm_cmpeq_epi8(transposed[1], first);
+
+  if (_mm_movemask_epi8(first) != 0xFFFF) {
+    return 0;
+  }
+
+  first = _mm_set1_epi8(block[2]);
+  first = _mm_cmpeq_epi8(transposed[2], first);
+
+  if (_mm_movemask_epi8(first) != 0xFFFF) {
+    return 0;
+  }
+
+  return 1;
+}
+
+inline void CompressSolid(uint8_t* dst, uint8_t* block) {
+  // Clear destination buffer so that we can "or" in the results.
+  memset(dst, 0, 8);
+
+  float src_color_float[3] = {static_cast<float>(block[0]),
+                              static_cast<float>(block[1]),
+                              static_cast<float>(block[2])};
+  Color base = MakeColor555(src_color_float);
+  Color constant;
+  constant.channels.b = block[0];
+  constant.channels.g = block[1];
+  constant.channels.r = block[2];
+
+  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 = std::numeric_limits<uint32_t>::max();
+
+  // Try all codeword tables to find the one giving the best results for this
+  // block.
+  for (unsigned int tbl_idx = 0; tbl_idx < 8; ++tbl_idx) {
+    // Try all modifiers in the current table to find which one gives the
+    // smallest error.
+    for (unsigned int mod_idx = 0; mod_idx < 4; ++mod_idx) {
+      int16_t lum = g_codeword_tables[tbl_idx][mod_idx];
+      const Color& color = MakeColor(base, lum);
+
+      uint32_t mod_err = GetColorError(constant, color);
+      if (mod_err < best_mod_err) {
+        best_tbl_idx = tbl_idx;
+        best_mod_idx = mod_idx;
+        best_mod_err = mod_err;
+
+        if (mod_err == 0)
+          break;  // We cannot do any better than this.
+      }
+    }
+
+    if (best_mod_err == 0)
+      break;
+  }
+
+  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 TextureCompressorETC1_SSE::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);
+
+  uint8_t block[64] __attribute__((aligned(16)));
+  __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) {
+      /* SSE */
+      LegacyExtractBlock(block, src + x * 4, width);
+      TransposeBlock(block, packed);
+      if (BlockIsConstant(block, packed) == 1) {
+        /* TODO(radu.velea): handle constant blocks in SSE */
+        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