Even more win64 warning fixes

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 257 matching lines @@
     return compress_heterogeneous_r11eac_block(block);
 }
 
 // This function is used by R11 EAC to compress 4x4 blocks
 // of 8-bit alpha into 64-bit values that comprise the compressed data.
 // 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.
 typedef uint64_t (*A84x4To64BitProc)(const uint8_t block[]);
 
 static bool compress_4x4_a8_to_64bit(uint8_t* dst, const uint8_t* src,
-                                     int width, int height, int rowBytes,
+                                     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;
     }
 
     int blocksX = width >> 2;
     int blocksY = height >> 2;
 
     uint8_t block[16];
@@ skipping 125 matching lines @@
     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.
-static uint64_t compress_r11eac_block_fast(const uint8_t* src, int rowBytes) {
+static uint64_t compress_r11eac_block_fast(const uint8_t* src, size_t rowBytes) {
     // Store each row of alpha values in an integer
     const uint32_t alphaRow1 = *(reinterpret_cast<const uint32_t*>(src));
     const uint32_t alphaRow2 = *(reinterpret_cast<const uint32_t*>(src + rowBytes));
     const uint32_t alphaRow3 = *(reinterpret_cast<const uint32_t*>(src + 2*rowBytes));
     const uint32_t alphaRow4 = *(reinterpret_cast<const uint32_t*>(src + 3*rowBytes));
 
     // Check for solid blocks. The explanations for these values
     // can be found in the comments of compress_r11eac_block above
     if (alphaRow1 == alphaRow2 && alphaRow1 == alphaRow3 && alphaRow1 == alphaRow4) {
         if (0 == alphaRow1) {
@@ skipping 20 matching lines @@
     // taken care of in interleave6.
     const uint32_t r1r2 = (indexRow1 << 3) | indexRow2;
     const uint32_t r3r4 = (indexRow3 << 3) | indexRow4;
     const uint64_t indices = interleave6(r1r2, r3r4);
 
     // Return the packed incdices in the least significant bits with the magic header
     return SkEndian_SwapBE64(0x8490000000000000ULL | indices);
 }
 
 static bool compress_a8_to_r11eac_fast(uint8_t* dst, const uint8_t* src,
-                                       int width, int height, int rowBytes) {
+                                       int width, int height, size_t rowBytes) {
     // 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;
     }
 
     const int blocksX = width >> 2;
     const int blocksY = height >> 2;
 
     uint64_t* encPtr = reinterpret_cast<uint64_t*>(dst);
     for (int y = 0; y < blocksY; ++y) {
@@ skipping 136 matching lines @@
         // the R11EAC indices directly correspond to pixel values.
         SkFAIL("Implement me!");
     }
 #endif
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace SkTextureCompressor {
 
-bool CompressA8ToR11EAC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) {
+bool CompressA8ToR11EAC(uint8_t* dst, const uint8_t* src, int width, int height, size_t rowBytes) {
 
 #if (COMPRESS_R11_EAC_SLOW) || (COMPRESS_R11_EAC_FAST)
 
     return compress_4x4_a8_to_64bit(dst, src, width, height, rowBytes, compress_r11eac_block);
 
 #elif COMPRESS_R11_EAC_FASTEST
 
     return compress_a8_to_r11eac_fast(dst, src, width, height, rowBytes);
 
 #else
@@ skipping 28 matching lines @@
     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