More Windows 64b compilation warning fixes

src/images/bmpdecoderhelper.cpp

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // Author: cevans@google.com (Chris Evans)
 
 #include "bmpdecoderhelper.h"
 
 namespace image_codec {
 
 static const int kBmpHeaderSize = 14;
 static const int kBmpInfoSize = 40;
 static const int kBmpOS2InfoSize = 12;
 static const int kMaxDim = SHRT_MAX / 2;
 
 bool BmpDecoderHelper::DecodeImage(const char* p,
-                                   int len,
+                                   size_t len,
                                    int max_pixels,
                                    BmpDecoderCallback* callback) {
   data_ = reinterpret_cast<const uint8*>(p);
   pos_ = 0;
   len_ = len;
   inverted_ = true;
   // Parse the header structure.
   if (len < kBmpHeaderSize + 4) {
     return false;
   }
@@ skipping 114 matching lines @@
     }
   } else {
     return false;
   }
   // Round the rowLen up to a multiple of 4.
   if (rowLen % 4 != 0) {
     rowPad_ = 4 - (rowLen % 4);
     rowLen += rowPad_;
   }
 
-  if (offset > 0 && offset > pos_ && offset < len_) {
+  if (offset > 0 && (size_t)offset > pos_ && (size_t)offset < len_) {
     pos_ = offset;
   }
   // Deliberately off-by-one; a load of BMPs seem to have their last byte
   // missing.
   if (!rle && (pos_ + (rowLen * height_) > len_ + 1)) {
     return false;
   }
 
   output_ = callback->SetSize(width_, height_);
   if (NULL == output_) {
     return true;  // meaning we succeeded, but they want us to stop now
   }
 
   if (rle && (bpp_ == 4 || bpp_ == 8)) {
     DoRLEDecode();
   } else {
     DoStandardDecode();
   }
   return true;
 }
 
 void BmpDecoderHelper::DoRLEDecode() {
   static const uint8 RLE_ESCAPE = 0;
   static const uint8 RLE_EOL = 0;
   static const uint8 RLE_EOF = 1;
   static const uint8 RLE_DELTA = 2;
   int x = 0;
   int y = height_ - 1;
-  while (pos_ < len_ - 1) {
+  while (pos_ + 1 < len_) {
     uint8 cmd = GetByte();
     if (cmd != RLE_ESCAPE) {
       uint8 pixels = GetByte();
       int num = 0;
       uint8 col = pixels;
       while (cmd-- && x < width_) {
         if (bpp_ == 4) {
           if (num & 1) {
             col = pixels & 0xf;
           } else {
             col = pixels >> 4;
           }
         }
         PutPixel(x++, y, col);
         num++;
       }
     } else {
       cmd = GetByte();
       if (cmd == RLE_EOF) {
         return;
       } else if (cmd == RLE_EOL) {
         x = 0;
         y--;
         if (y < 0) {
           return;
         }
       } else if (cmd == RLE_DELTA) {
-        if (pos_ < len_ - 1) {
+        if (pos_ + 1 < len_) {
           uint8 dx = GetByte();
           uint8 dy = GetByte();
           x += dx;
           if (x > width_) {
             x = width_;
           }
           y -= dy;
           if (y < 0) {
             return;
           }
@@ skipping 105 matching lines @@
   return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
 }
 
 int BmpDecoderHelper::GetShort() {
   uint8 b1 = GetByte();
   uint8 b2 = GetByte();
   return b1 | (b2 << 8);
 }
 
 uint8 BmpDecoderHelper::GetByte() {
-  CHECK(pos_ >= 0 && pos_ <= len_);
+  CHECK(pos_ <= len_);
   // We deliberately allow this off-by-one access to cater for BMPs with their
   // last byte missing.
   if (pos_ == len_) {
     return 0;
   }
   return data_[pos_++];
 }
 
 int BmpDecoderHelper::CalcShiftRight(uint32 mask) {
   int ret = 0;
@@ skipping 10 matching lines @@
     mask >>= 1;
   }
   while (mask != 0 && !(mask & 0x80)) {
     mask <<= 1;
     ret++;
   }
   return ret;
 }
 
 }  // namespace image_codec