Style bikeshed - remove extraneous whitespace

src/utils/SkTextureCompressor_ASTC.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_ASTC.h"
 #include "SkTextureCompressor_Blitter.h"
 
@@ skipping 199 matching lines @@
     // Pack indices... The ASTC block layout is fairly complicated. An extensive
     // description can be found here:
     // https://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt
     //
     // Here is a summary of the options that we've chosen:
     // 1. Block mode: 0b00101110011
     //     - 6x5 texel grid
     //     - Single plane
     //     - Low-precision index values
     //     - Index range 0-7 (three bits per index)
-    // 2. Partitions: 0b00 
+    // 2. Partitions: 0b00
     //     - One partition
     // 3. Color Endpoint Mode: 0b0000
     //     - Direct luminance -- e0=(v0,v0,v0,0xFF); e1=(v1,v1,v1,0xFF);
     // 4. 8-bit endpoints:
     //     v0 = 0, v1 = 255
     //
     // The rest of the block contains the 30 index values from before, which
     // are currently stored in the indices variable.
 
     uint64_t top = 0x0000000001FE000173ULL;
@@ skipping 32 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // ASTC Decoder
 //
 // Full details available in the spec:
 // http://www.khronos.org/registry/gles/extensions/OES/OES_texture_compression_astc.txt
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-// Enable this to assert whenever a decoded block has invalid ASTC values. Otherwise, 
+// Enable this to assert whenever a decoded block has invalid ASTC values. Otherwise,
 // each invalid block will result in a disgusting magenta color.
 #define ASSERT_ASTC_DECODE_ERROR 0
 
 // Reverse 64-bit integer taken from TAOCP 4a, although it's better
 // documented at this site:
 // http://matthewarcus.wordpress.com/2012/11/18/reversing-a-64-bit-word/
 
 template <typename T, T m, int k>
 static inline T swap_bits(T p) {
     T q = ((p>>k)^p) & m;
@@ skipping 78 matching lines @@
         // All desired bits are in the low 64-bits.
         result = (block.fLow >> from) & ((1ULL << nBits) - 1);
     } else if (from >= 64) {
         // All desired bits are in the high 64-bits.
         result = (block.fHigh >> (from - 64)) & ((1ULL << nBits) - 1);
     } else {
         // from < 64 && to > 64
         SkASSERT(nBits > (64 - from));
         const int nLow = 64 - from;
         const int nHigh = nBits - nLow;
-        result = 
+        result =
             ((block.fLow >> from) & ((1ULL << nLow) - 1)) |
             ((block.fHigh & ((1ULL << nHigh) - 1)) << nLow);
     }
 
     return result;
 }
 
 // Returns the number of bits needed to represent a number
 // in the given power-of-two range (excluding the power of two itself).
 static inline int bits_for_range(int x) {
@@ skipping 62 matching lines @@
 //   kLDR_RGB_BaseScale_ColorEndpointMode
 //   kLDR_RGB_BaseScaleWithAlpha_ColorEndpointMode
 static inline void decode_rgba_basescale(const int *v, SkColor *endpoints, bool isRGB) {
 
     int v4 = 0xFF;
     int v5 = 0xFF;
     if (!isRGB) {
         v4 = v[4];
         v5 = v[5];
     }
-                  
+
     endpoints[0] = SkColorSetARGB(v4,
                                   (v[0]*v[3]) >> 8,
                                   (v[1]*v[3]) >> 8,
                                   (v[2]*v[3]) >> 8);
     endpoints[1] = SkColorSetARGB(v5, v[0], v[1], v[2]);
 }
 
 // Helper function that decodes two colors from eight values. If isRGB is true,
 // then the pointer 'v' contains six values and the last two are considered to be
 // 0xFF. If isRGB is false, then all eight values come from the pointer 'v'. This
@@ skipping 783 matching lines @@
 
                     endpoints[i][0] = SkColorSetARGB(0xFF, L0, L0, L0);
                     endpoints[i][1] = SkColorSetARGB(0xFF, L1, L1, L1);
 
                     colorValues += 2;
                 }
                 break;
 
                 case kLDR_LuminanceAlpha_Direct_ColorEndpointMode: {
                     const int* v = colorValues;
-                    
+
                     endpoints[i][0] = SkColorSetARGB(v[2], v[0], v[0], v[0]);
                     endpoints[i][1] = SkColorSetARGB(v[3], v[1], v[1], v[1]);
 
                     colorValues += 4;
                 }
                 break;
 
                 case kLDR_LuminanceAlpha_BaseOffset_ColorEndpointMode: {
                     int v0 = colorValues[0];
                     int v1 = colorValues[1];
                     int v2 = colorValues[2];
                     int v3 = colorValues[3];
 
                     bit_transfer_signed(&v1, &v0);
                     bit_transfer_signed(&v3, &v2);
-                    
+
                     endpoints[i][0] = SkColorSetARGB(v2, v0, v0, v0);
                     endpoints[i][1] = SkColorSetARGB(
                         clamp_byte(v3+v2),
                         clamp_byte(v1+v0),
                         clamp_byte(v1+v0),
                         clamp_byte(v1+v0));
 
                     colorValues += 4;
                 }
                 break;
@@ skipping 376 matching lines @@
 
         // If there's only one partition, then our job is (relatively) easy.
         if (this->numPartitions() == 1) {
             fCEM[0] = static_cast<ColorEndpointMode>(read_astc_bits(fBlock, 13, 17));
             fColorStartBit = 17;
 
             // Handle dual plane mode...
             this->decodeDualPlane(dualPlaneBitLoc);
 
             return;
-        } 
+        }
 
         // If we have more than one partition, then we need to make
         // room for the partition index.
         fColorStartBit = 29;
 
         // Read the base CEM. If it's zero, then we have no additional
         // CEM data and the endpoints for each partition share the same CEM.
         const int baseCEM = static_cast<int>(read_astc_bits(fBlock, 23, 25));
         if (0 == baseCEM) {
 
             const ColorEndpointMode sameCEM =
                 static_cast<ColorEndpointMode>(read_astc_bits(fBlock, 25, 29));
 
             for (int i = 0; i < kMaxPartitions; ++i) {
                 fCEM[i] = sameCEM;
             }
 
             // Handle dual plane mode...
             this->decodeDualPlane(dualPlaneBitLoc);
 
             return;
-        } 
+        }
 
         // Move the dual plane selector bits down based on how many
         // partitions the block contains.
         switch (this->numPartitions()) {
             case 2:
                 dualPlaneBitLoc -= 2;
                 break;
 
             case 3:
                 dualPlaneBitLoc -= 5;
@@ skipping 44 matching lines @@
             SkASSERT(cem < 16);
             fCEM[i] = static_cast<ColorEndpointMode>(cem);
         }
 
         // Finally, if we have dual plane mode, then read the plane selector.
         this->decodeDualPlane(dualPlaneBitLoc);
     }
 
     // Decodes the block mode. This function determines whether or not we use
     // dual plane encoding, the size of the texel weight grid, and the number of
-    // bits, trits and quints that are used to encode it. For more information, 
+    // bits, trits and quints that are used to encode it. For more information,
     // see section C.2.10 of the ASTC spec.
     //
     // For 2D blocks, the Block Mode field is laid out as follows:
     //
     // -------------------------------------------------------------------------
     // 10  9   8   7   6   5   4   3   2   1   0   Width Height Notes
     // -------------------------------------------------------------------------
     // D   H     B       A     R0  0   0   R2  R1  B+4   A+2
     // D   H     B       A     R0  0   1   R2  R1  B+8   A+2
     // D   H     B       A     R0  1   0   R2  R1  A+2   B+8
@@ skipping 322 matching lines @@
             read_astc_block(&data, src);
             decompress_astc_block(reinterpret_cast<uint8_t*>(colorPtr + x), dstRowBytes, data);
 
             // ASTC encoded blocks are 16 bytes (128 bits) large.
             src += 16;
         }
     }
 }
 
 }  // SkTextureCompressor