Style bikeshed - remove extraneous whitespace

src/utils/SkTextureCompressor_LATC.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTextureCompressor_LATC.h"
 #include "SkTextureCompressor_Blitter.h"
 #include "SkTextureCompressor_Utils.h"
@@ skipping 63 matching lines @@
 }
 
 static bool is_extremal(uint8_t pixel) {
     return 0 == pixel || 255 == pixel;
 }
 
 typedef uint64_t (*A84x4To64BitProc)(const uint8_t block[]);
 
 // This function is used by both R11 EAC and LATC to compress 4x4 blocks
 // of 8-bit alpha into 64-bit values that comprise the compressed data.
-// For both formats, we need to make sure that the dimensions of the 
+// For both formats, we need to make sure that the dimensions of the
 // src pixels are divisible by 4, and copy 4x4 blocks one at a time
 // for compression.
 static bool compress_4x4_a8_to_64bit(uint8_t* dst, const uint8_t* src,
                                      int width, int height, size_t rowBytes,
                                      A84x4To64BitProc proc) {
     // Make sure that our data is well-formed enough to be considered for compression
     if (0 == width || 0 == height || (width % 4) != 0 || (height % 4) != 0) {
         return false;
     }
 
@@ skipping 182 matching lines @@
         if (!is_extremal(uniquePixels[i])) {
             ++nonExtremalPixels;
         }
     }
 
     // If all the pixels are nonmaximal then compute the palette using
     // the bounding box of all the pixels.
     if (nonExtremalPixels == nUniquePixels) {
         // This is really just for correctness, in all of my tests we
         // never take this step. We don't lose too much perf here because
-        // most of the processing in this function is worth it for the 
+        // most of the processing in this function is worth it for the
         // 1 == nUniquePixels optimization.
         return compress_latc_block_bb(pixels);
     } else {
         return compress_latc_block_bb_ignore_extremal(pixels);
     }
 }
 
 #endif  // COMPRESS_LATC_SLOW
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 15 matching lines @@
         (x & 0x7) |
         ((x >> 5) & 0x38) |
         ((x >> 10) & 0x1C0) |
         ((x >> 15) & 0xE00);
 #endif
 }
 
 // Converts each 8-bit byte in the integer into an LATC index, and then packs
 // the indices into the low 12 bits of the integer.
 static inline uint32_t convert_index(uint32_t x) {
-    // Since the palette is 
+    // Since the palette is
     // 255, 0, 219, 182, 146, 109, 73, 36
     // we need to map the high three bits of each byte in the integer
     // from
     // 0 1 2 3 4 5 6 7
     // to
     // 1 7 6 5 4 3 2 0
     //
     // This first operation takes the mapping from
     // 0 1 2 3 4 5 6 7  -->  7 6 5 4 3 2 1 0
     x = 0x07070707 - SkTextureCompressor::ConvertToThreeBitIndex(x);
 
     // mask is 1 if index is non-zero
     const uint32_t mask = (x | (x >> 1) | (x >> 2)) & 0x01010101;
 
     // add mask:
     // 7 6 5 4 3 2 1 0 --> 8 7 6 5 4 3 2 0
     x = (x + mask);
 
     // Handle overflow:
     // 8 7 6 5 4 3 2 0 --> 9 7 6 5 4 3 2 0
     x |= (x >> 3) & 0x01010101;
 
     // Mask out high bits:
     // 9 7 6 5 4 3 2 0 --> 1 7 6 5 4 3 2 0
     x &= 0x07070707;
-    
+
     return pack_index(x);
 }
 
 typedef uint64_t (*PackIndicesProc)(const uint8_t* alpha, size_t rowBytes);
 template<PackIndicesProc packIndicesProc>
 static void compress_a8_latc_block(uint8_t** dstPtr, const uint8_t* src, size_t rowBytes) {
     *(reinterpret_cast<uint64_t*>(*dstPtr)) =
         SkEndian_SwapLE64(0xFF | (packIndicesProc(src, rowBytes) << 16));
     *dstPtr += 8;
 }
@@ skipping 150 matching lines @@
     for (int j = 0; j < height; j += 4) {
         for (int i = 0; i < width; i += 4) {
             decompress_latc_block(dst + i, dstRowBytes, src);
             src += 8;
         }
         dst += 4 * dstRowBytes;
     }
 }
 
 }  // SkTextureCompressor