compress_r11eac_blocks() required more alignment than dst has.

src/opts/SkTextureCompressor_opts.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTextureCompressor_opts_DEFINED
 #define SkTextureCompressor_opts_DEFINED
 
@@ skipping 132 matching lines @@
     #if defined (SK_CPU_BENDIAN)
     static inline uint64x2_t fix_endianness(uint64x2_t x) {
         return x;
     }
     #else
     static inline uint64x2_t fix_endianness(uint64x2_t x) {
         return vreinterpretq_u64_u8(vrev64q_u8(vreinterpretq_u8_u64(x)));
     }
     #endif
 
-    static void compress_r11eac_blocks(uint64_t* dst, const uint8_t* src, size_t rowBytes) {
+    static void compress_r11eac_blocks(uint8_t* dst, const uint8_t* src, size_t rowBytes) {
         // Try to avoid switching between vector and non-vector ops...
         const uint8_t *const src1 = src;
         const uint8_t *const src2 = src + rowBytes;
         const uint8_t *const src3 = src + 2*rowBytes;
         const uint8_t *const src4 = src + 3*rowBytes;
-        uint64_t *const dst1 = dst;
-        uint64_t *const dst2 = dst + 2;
+        uint8_t *const dst1 = dst;
+        uint8_t *const dst2 = dst + 16;
 
         const uint8x16_t alphaRow1 = vld1q_u8(src1);
         const uint8x16_t alphaRow2 = vld1q_u8(src2);
         const uint8x16_t alphaRow3 = vld1q_u8(src3);
         const uint8x16_t alphaRow4 = vld1q_u8(src4);
 
         const uint8x16_t cmp12 = vceqq_u8(alphaRow1, alphaRow2);
         const uint8x16_t cmp34 = vceqq_u8(alphaRow3, alphaRow4);
         const uint8x16_t cmp13 = vceqq_u8(alphaRow1, alphaRow3);
 
         const uint8x16_t cmp = vandq_u8(vandq_u8(cmp12, cmp34), cmp13);
         const uint8x16_t ncmp = vmvnq_u8(cmp);
         const uint8x16_t nAlphaRow1 = vmvnq_u8(alphaRow1);
         if (is_zero(ncmp)) {
             if (is_zero(alphaRow1)) {
                 static const uint64x2_t kTransparent = { 0x0020000000002000ULL,
                                                          0x0020000000002000ULL };
-                vst1q_u64(dst1, kTransparent);
-                vst1q_u64(dst2, kTransparent);
+                vst1q_u8(dst1, vreinterpretq_u8_u64(kTransparent));
+                vst1q_u8(dst2, vreinterpretq_u8_u64(kTransparent));
                 return;
             } else if (is_zero(nAlphaRow1)) {
-                vst1q_u64(dst1, vreinterpretq_u64_u8(cmp));
-                vst1q_u64(dst2, vreinterpretq_u64_u8(cmp));
+                vst1q_u8(dst1, cmp);
+                vst1q_u8(dst2, cmp);
                 return;
             }
         }
 
         const uint8x16_t indexRow1 = convert_indices(make_index_row(alphaRow1));
         const uint8x16_t indexRow2 = convert_indices(make_index_row(alphaRow2));
         const uint8x16_t indexRow3 = convert_indices(make_index_row(alphaRow3));
         const uint8x16_t indexRow4 = convert_indices(make_index_row(alphaRow4));
 
         const uint64x2_t indexRow12 = vreinterpretq_u64_u8(
             vorrq_u8(vshlq_n_u8(indexRow1, 3), indexRow2));
         const uint64x2_t indexRow34 = vreinterpretq_u64_u8(
             vorrq_u8(vshlq_n_u8(indexRow3, 3), indexRow4));
 
         const uint32x4x2_t blockIndices = vtrnq_u32(vreinterpretq_u32_u64(indexRow12),
                                                     vreinterpretq_u32_u64(indexRow34));
         const uint64x2_t blockIndicesLeft = vreinterpretq_u64_u32(vrev64q_u32(blockIndices.val[0]));
         const uint64x2_t blockIndicesRight = vreinterpretq_u64_u32(vrev64q_u32(blockIndices.val[1]));
 
         const uint64x2_t indicesLeft = fix_endianness(pack_indices(blockIndicesLeft));
         const uint64x2_t indicesRight = fix_endianness(pack_indices(blockIndicesRight));
 
         const uint64x2_t d1 = vcombine_u64(vget_low_u64(indicesLeft), vget_low_u64(indicesRight));
         const uint64x2_t d2 = vcombine_u64(vget_high_u64(indicesLeft), vget_high_u64(indicesRight));
-        vst1q_u64(dst1, d1);
-        vst1q_u64(dst2, d2);
+        vst1q_u8(dst1, vreinterpretq_u8_u64(d1));
+        vst1q_u8(dst2, vreinterpretq_u8_u64(d2));
     }
 
     static bool compress_a8_r11eac(uint8_t* dst, const uint8_t* src,
                                    int width, int height, size_t rowBytes) {
 
         // Since we're going to operate on 4 blocks at a time, the src width
         // must be a multiple of 16. However, the height only needs to be a
         // multiple of 4
         if (0 == width || 0 == height || (width % 16) != 0 || (height % 4) != 0) {
             return false;
         }
 
         const int blocksX = width >> 2;
         const int blocksY = height >> 2;
 
         SkASSERT((blocksX % 4) == 0);
 
-        uint64_t* encPtr = reinterpret_cast<uint64_t*>(dst);
         for (int y = 0; y < blocksY; ++y) {
             for (int x = 0; x < blocksX; x+=4) {
                 // Compress it
-                compress_r11eac_blocks(encPtr, src + 4*x, rowBytes);
-                encPtr += 4;
+                compress_r11eac_blocks(dst, src + 4*x, rowBytes);
+                dst += 32;
             }
             src += 4 * rowBytes;
         }
         return true;
     }
 
     static SkOpts::TextureCompressor texture_compressor(SkColorType ct,
                                                         SkTextureCompressor::Format fmt) {
         if (ct == kAlpha_8_SkColorType && fmt == SkTextureCompressor::kR11_EAC_Format) {
             return compress_a8_r11eac;
@@ skipping 15 matching lines @@
     }
     static bool fill_block_dimensions(SkTextureCompressor::Format, int*, int*) {
         return false;
     }
 
 #endif
 
 }  // namespace SK_OPTS_NS
 
 #endif//SkTextureCompressor_opts_DEFINED