Style bikeshed - remove extraneous whitespace

src/utils/SkTextureCompressor_R11EAC.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.h"
 #include "SkTextureCompressor_Blitter.h"
 #include "SkTextureCompressor_Utils.h"
@@ skipping 217 matching lines @@
             // Fully transparent? We know the encoding...
             case 0:
                 // (0x0020 << 48) produces the following:
                 // basw_cw: 0
                 // mod: 0, palette: {-3, -6, -9, -15, 2, 5, 8, 14}
                 // multiplier: 2
                 // mod_val: -3
                 //
                 // this gives the following formula:
                 // clamp[0, 2047](0*8+4+(-3)*2*8) = 0
-                // 
+                //
                 // Furthermore, it is impervious to endianness:
                 // 0x0020000000002000ULL
                 // Will produce one pixel with index 2, which gives:
                 // clamp[0, 2047](0*8+4+(-9)*2*8) = 0
                 return 0x0020000000002000ULL;
 
             // Fully opaque? We know this encoding too...
             case 255:
-            
+
                 // -1 produces the following:
                 // basw_cw: 255
                 // mod: 15, palette: {-3, -5, -7, -9, 2, 4, 6, 8}
                 // mod_val: 8
                 //
                 // this gives the following formula:
                 // clamp[0, 2047](255*8+4+8*8*8) = clamp[0, 2047](2556) = 2047
                 return 0xFFFFFFFFFFFFFFFFULL;
 
             default:
@@ skipping 145 matching lines @@
 
     x = swap_shift<12>(x, 0xFFF000000ULL);
 #else
     // If our CPU is little endian, then the above logic will
     // produce the following indices:
     // x: 00 00 00 00 00 00 00 00 c g i m d h l p b f j n a e k o
 
     x = swap_shift<36>(x, 0xFC0ULL);
 
     // x: 00 00 00 00 00 00 00 00 a e i m d h l p b f j n c g k o
-    
+
     x = (x & (0xFFFULL << 36)) | ((x & 0xFFFFFFULL) << 12) | ((x >> 24) & 0xFFFULL);
 #endif
 
     // x: 00 00 00 00 00 00 00 00 a e i m b f j n c g k o d h l p
     return x;
 }
 
 // This function follows the same basic procedure as compress_heterogeneous_r11eac_block
 // above when COMPRESS_R11_EAC_FAST is defined, but it avoids a few loads/stores and
 // tries to optimize where it can using SIMD.
@@ skipping 67 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // The R11 EAC format expects that indices are given in column-major order. Since
 // we receive alpha values in raster order, this usually means that we have to use
 // pack6 above to properly pack our indices. However, if our indices come from the
 // blitter, then each integer will be a column of indices, and hence can be efficiently
 // packed. This function takes the bottom three bits of each byte and places them in
 // the least significant 12 bits of the resulting integer.
 static inline uint32_t pack_indices_vertical(uint32_t x) {
 #if defined (SK_CPU_BENDIAN)
-    return 
+    return
         (x & 7) |
         ((x >> 5) & (7 << 3)) |
         ((x >> 10) & (7 << 6)) |
         ((x >> 15) & (7 << 9));
 #else
-    return 
+    return
         ((x >> 24) & 7) |
         ((x >> 13) & (7 << 3)) |
         ((x >> 2) & (7 << 6)) |
         ((x << 9) & (7 << 9));
 #endif
 }
 
 // This function returns the compressed format of a block given as four columns of
 // alpha values. Each column is assumed to be loaded from top to bottom, and hence
 // must first be converted to indices and then packed into the resulting 64-bit
@@ skipping 139 matching lines @@
         (width, height, outputBuffer);
 }
 
 void DecompressR11EAC(uint8_t* dst, int dstRowBytes, const uint8_t* src, int width, int height) {
     for (int j = 0; j < height; j += 4) {
         for (int i = 0; i < width; i += 4) {
             decompress_r11_eac_block(dst + i, dstRowBytes, src);
             src += 8;
         }
         dst += 4 * dstRowBytes;
-    }    
+    }
 }
 
 }  // namespace SkTextureCompressor