Even more win64 warning fixes

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 67 matching lines @@
 }
 
 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 
 // 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, 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 244 matching lines @@
     // 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, int rowBytes);
+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, int rowBytes) {
+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;
 }
 
-inline uint64_t PackRowMajor(const uint8_t *indices, int rowBytes) {
+inline uint64_t PackRowMajor(const uint8_t *indices, size_t rowBytes) {
     uint64_t result = 0;
     for (int i = 0; i < 4; ++i) {
         const uint32_t idx = *(reinterpret_cast<const uint32_t*>(indices + i*rowBytes));
         result |= static_cast<uint64_t>(convert_index(idx)) << 12*i;
     }
     return result;
 }
 
-inline uint64_t PackColumnMajor(const uint8_t *indices, int rowBytes) {
+inline uint64_t PackColumnMajor(const uint8_t *indices, size_t rowBytes) {
     // !SPEED! Blarg, this is kind of annoying. SSE4 can make this
     // a LOT faster.
     uint8_t transposed[16];
     for (int i = 0; i < 4; ++i) {
         for (int j = 0; j < 4; ++j) {
             transposed[j*4+i] = indices[i*rowBytes + j];
         }
     }
 
     return PackRowMajor(transposed, 4);
 }
 
 static bool compress_4x4_a8_latc(uint8_t* dst, const uint8_t* src,
-                                 int width, int height, int rowBytes) {
+                                 int width, int height, size_t rowBytes) {
 
     if (width < 0 || ((width % 4) != 0) || height < 0 || ((height % 4) != 0)) {
         return false;
     }
 
     uint8_t** dstPtr = &dst;
     for (int y = 0; y < height; y += 4) {
         for (int x = 0; x < width; x += 4) {
             compress_a8_latc_block<PackRowMajor>(dstPtr, src + y*rowBytes + x, rowBytes);
         }
@@ skipping 70 matching lines @@
         *cmpDst &= ~cmpMask;
         *cmpDst |= cmpSrc;
     }
 #endif  // PEDANTIC_BLIT_RECT
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace SkTextureCompressor {
 
-bool CompressA8ToLATC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) {
+bool CompressA8ToLATC(uint8_t* dst, const uint8_t* src, int width, int height, size_t rowBytes) {
 #if COMPRESS_LATC_FAST
     return compress_4x4_a8_latc(dst, src, width, height, rowBytes);
 #elif COMPRESS_LATC_SLOW
     return compress_4x4_a8_to_64bit(dst, src, width, height, rowBytes, compress_latc_block);
 #else
 #error "Must choose either fast or slow LATC compression"
 #endif
 }
 
 SkBlitter* CreateLATCBlitter(int width, int height, void* outputBuffer,
@@ skipping 24 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