fix warnings around size_t/int

src/core/SkPackBits.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPackBits.h"
 
 #define GATHER_STATSx
 
 static inline void small_memcpy(void* SK_RESTRICT dst,
-                                const void* SK_RESTRICT src, int n) {
+                                const void* SK_RESTRICT src, size_t n) {
     SkASSERT(n > 0 && n <= 15);
     uint8_t* d = (uint8_t*)dst;
     const uint8_t* s = (const uint8_t*)src;
     switch (n) {
         case 15: *d++ = *s++;
         case 14: *d++ = *s++;
         case 13: *d++ = *s++;
         case 12: *d++ = *s++;
         case 11: *d++ = *s++;
         case 10: *d++ = *s++;
         case  9: *d++ = *s++;
         case  8: *d++ = *s++;
         case  7: *d++ = *s++;
         case  6: *d++ = *s++;
         case  5: *d++ = *s++;
         case  4: *d++ = *s++;
         case  3: *d++ = *s++;
         case  2: *d++ = *s++;
         case  1: *d++ = *s++;
         case  0: break;
     }
 }
 
-static inline void small_memset(void* dst, uint8_t value, int n) {
+static inline void small_memset(void* dst, uint8_t value, size_t n) {
     SkASSERT(n > 0 && n <= 15);
     uint8_t* d = (uint8_t*)dst;
     switch (n) {
         case 15: *d++ = value;
         case 14: *d++ = value;
         case 13: *d++ = value;
         case 12: *d++ = value;
         case 11: *d++ = value;
         case 10: *d++ = value;
         case  9: *d++ = value;
@@ skipping 141 matching lines @@
     }
     return dst;
 }
 
 size_t SkPackBits::Pack16(const uint16_t* SK_RESTRICT src, int count,
                           uint8_t* SK_RESTRICT dst) {
     uint8_t* origDst = dst;
     const uint16_t* stop = src + count;
 
     for (;;) {
-        count = stop - src;
+        count = SkToInt(stop - src);
         SkASSERT(count >= 0);
         if (count == 0) {
             return dst - origDst;
         }
         if (1 == count) {
             *dst++ = 0;
             *dst++ = (uint8_t)(*src >> 8);
             *dst++ = (uint8_t)*src;
             return dst - origDst;
         }
 
         unsigned value = *src;
         const uint16_t* s = src + 1;
 
         if (*s == value) { // accumulate same values...
             do {
                 s++;
                 if (s == stop) {
                     break;
                 }
             } while (*s == value);
-            dst = flush_same16(dst, value, s - src);
+            dst = flush_same16(dst, value, SkToInt(s - src));
         } else {    // accumulate diff values...
             do {
                 if (++s == stop) {
                     goto FLUSH_DIFF;
                 }
             } while (*s != s[-1]);
             s -= 1; // back up so we don't grab one of the "same" values that follow
         FLUSH_DIFF:
-            dst = flush_diff16(dst, src, s - src);
+            dst = flush_diff16(dst, src, SkToInt(s - src));
         }
         src = s;
     }
 }
 
 size_t SkPackBits::Pack8(const uint8_t* SK_RESTRICT src, int count,
                          uint8_t* SK_RESTRICT dst) {
     uint8_t* origDst = dst;
     const uint8_t* stop = src + count;
 
     for (;;) {
-        count = stop - src;
+        count = SkToInt(stop - src);
         SkASSERT(count >= 0);
         if (count == 0) {
             return dst - origDst;
         }
         if (1 == count) {
             *dst++ = 0;
             *dst++ = *src;
             return dst - origDst;
         }
 
         unsigned value = *src;
         const uint8_t* s = src + 1;
 
         if (*s == value) { // accumulate same values...
             do {
                 s++;
                 if (s == stop) {
                     break;
                 }
             } while (*s == value);
-            dst = flush_same8(dst, value, s - src);
+            dst = flush_same8(dst, value, SkToInt(s - src));
         } else {    // accumulate diff values...
             do {
                 if (++s == stop) {
                     goto FLUSH_DIFF;
                 }
                 // only stop if we hit 3 in a row,
                 // otherwise we get bigger than compuatemax
             } while (*s != s[-1] || s[-1] != s[-2]);
             s -= 2; // back up so we don't grab the "same" values that follow
         FLUSH_DIFF:
-            dst = flush_diff8(dst, src, s - src);
+            dst = flush_diff8(dst, src, SkToInt(s - src));
         }
         src = s;
     }
 }
 
 #include "SkUtils.h"
 
 int SkPackBits::Unpack16(const uint8_t* SK_RESTRICT src, size_t srcSize,
                          uint16_t* SK_RESTRICT dst) {
     uint16_t* origDst = dst;
     const uint8_t* stop = src + srcSize;
 
     while (src < stop) {
         unsigned n = *src++;
         if (n <= 127) {   // repeat count (n + 1)
             n += 1;
             sk_memset16(dst, (src[0] << 8) | src[1], n);
             src += 2;
         } else {    // same count (n - 127)
             n -= 127;
             PB_MEMCPY(dst, src, n * sizeof(uint16_t));
             src += n * sizeof(uint16_t);
         }
         dst += n;
     }
     SkASSERT(src == stop);
-    return dst - origDst;
+    return SkToInt(dst - origDst);
 }
 
 int SkPackBits::Unpack8(const uint8_t* SK_RESTRICT src, size_t srcSize,
                         uint8_t* SK_RESTRICT dst) {
     uint8_t* origDst = dst;
     const uint8_t* stop = src + srcSize;
 
     while (src < stop) {
         unsigned n = *src++;
         if (n <= 127) {   // repeat count (n + 1)
             n += 1;
             PB_MEMSET(dst, *src++, n);
         } else {    // same count (n - 127)
             n -= 127;
             PB_MEMCPY(dst, src, n);
             src += n;
         }
         dst += n;
     }
     SkASSERT(src == stop);
-    return dst - origDst;
+    return SkToInt(dst - origDst);
 }
 
 enum UnpackState {
     CLEAN_STATE,
     REPEAT_BYTE_STATE,
     COPY_SRC_STATE
 };
 
 void SkPackBits::Unpack8(uint8_t* SK_RESTRICT dst, size_t dstSkip,
                          size_t dstWrite, const uint8_t* SK_RESTRICT src) {
     if (dstWrite == 0) {
         return;
     }
 
     UnpackState state = CLEAN_STATE;
     size_t      stateCount = 0;
 
     // state 1: do the skip-loop
     while (dstSkip > 0) {
-        unsigned n = *src++;
+        size_t n = *src++;
         if (n <= 127) {   // repeat count (n + 1)
             n += 1;
             if (n > dstSkip) {
                 state = REPEAT_BYTE_STATE;
                 stateCount = n - dstSkip;
                 n = dstSkip;
                 // we don't increment src here, since its needed in stage 2
             } else {
                 src++;  // skip the src byte
             }
@@ skipping 27 matching lines @@
             break;
         default:
             SkASSERT(stateCount == 0);
             break;
     }
     dst += stateCount;
     dstWrite -= stateCount;
 
     // copy at most dstWrite bytes into dst[]
     while (dstWrite > 0) {
-        unsigned n = *src++;
+        size_t n = *src++;
         if (n <= 127) {   // repeat count (n + 1)
             n += 1;
             if (n > dstWrite) {
                 n = dstWrite;
             }
             register_memset_count(n);
             PB_MEMSET(dst, *src++, n);
         } else {    // same count (n - 127)
             n -= 127;
             if (n > dstWrite) {
                 n = dstWrite;
             }
             register_memcpy_count(n);
             PB_MEMCPY(dst, src, n);
             src += n;
         }
         dst += n;
         dstWrite -= n;
     }
     SkASSERT(0 == dstWrite);
 }