diff --git a/README.chromium b/README.chromium
index a2ab5c27d..263b7acb0 100644
--- a/README.chromium
+++ b/README.chromium
@@ -1,6 +1,6 @@
 Name: libyuv
 URL: http://code.google.com/p/libyuv/
-Version: 1624
+Version: 1625
 License: BSD
 License File: LICENSE
 
diff --git a/include/libyuv/version.h b/include/libyuv/version.h
index d237d78ab..2abd17d39 100644
--- a/include/libyuv/version.h
+++ b/include/libyuv/version.h
@@ -11,6 +11,6 @@
 #ifndef INCLUDE_LIBYUV_VERSION_H_
 #define INCLUDE_LIBYUV_VERSION_H_
 
-#define LIBYUV_VERSION 1624
+#define LIBYUV_VERSION 1625
 
 #endif  // INCLUDE_LIBYUV_VERSION_H_
diff --git a/unit_test/compare_test.cc b/unit_test/compare_test.cc
index a8ce671d6..ecdc8cac4 100644
--- a/unit_test/compare_test.cc
+++ b/unit_test/compare_test.cc
@@ -157,19 +157,19 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
   src_a[0] = 0;
   fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
                       benchmark_width_, benchmark_height_);
-  EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
+  EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_BGRA), fourcc);
   src_a[0] = 255;
   src_a[3] = 0;
   fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
                       benchmark_width_, benchmark_height_);
-  EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc);
+  EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_ARGB), fourcc);
   src_a[3] = 255;
 
   for (int i = 0; i < benchmark_iterations_; ++i) {
     fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
                         benchmark_width_, benchmark_height_);
   }
-  EXPECT_EQ(0, fourcc);
+  EXPECT_EQ(0u, fourcc);
 
   free_aligned_buffer_page_end(src_a);
 }
@@ -185,19 +185,19 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
   src_a[0 + 1] = 0;
   fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
                       benchmark_width_, benchmark_height_);
-  EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
+  EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_BGRA), fourcc);
   src_a[0 + 1] = 255;
   src_a[3 + 1] = 0;
   fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
                       benchmark_width_, benchmark_height_);
-  EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc);
+  EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_ARGB), fourcc);
   src_a[3 + 1] = 255;
 
   for (int i = 0; i < benchmark_iterations_; ++i) {
     fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
                         benchmark_width_, benchmark_height_);
   }
-  EXPECT_EQ(0, fourcc);
+  EXPECT_EQ(0u, fourcc);
 
   free_aligned_buffer_page_end(src_a);
 }
@@ -226,7 +226,7 @@ TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
     h1 = ComputeSumSquareError(src_a, src_b, kMaxWidth);
   }
 
-  EXPECT_EQ(0, h1);
+  EXPECT_EQ(0u, h1);
 
   free_aligned_buffer_page_end(src_a);
   free_aligned_buffer_page_end(src_b);
@@ -242,18 +242,18 @@ TEST_F(LibYUVBaseTest, SumSquareError) {
   uint64 err;
   err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
 
-  EXPECT_EQ(0, err);
+  EXPECT_EQ(0u, err);
 
   memset(src_a, 1, kMaxWidth);
   err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
 
-  EXPECT_EQ(err, kMaxWidth);
+  EXPECT_EQ(static_cast<int>(err), kMaxWidth);
 
   memset(src_a, 190, kMaxWidth);
   memset(src_b, 193, kMaxWidth);
   err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
 
-  EXPECT_EQ(kMaxWidth * 3 * 3, err);
+  EXPECT_EQ(static_cast<int>(err), kMaxWidth * 3 * 3);
 
   for (int i = 0; i < kMaxWidth; ++i) {
     src_a[i] = (fastrand() & 0xff);
diff --git a/unit_test/convert_test.cc b/unit_test/convert_test.cc
index 24a18249b..6cf30ad0f 100644
--- a/unit_test/convert_test.cc
+++ b/unit_test/convert_test.cc
@@ -2017,7 +2017,6 @@ TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) {                \
                           dst_argb_b + OFF, kStrideB,                          \
                           kWidth, NEG kHeight, ATTEN);                         \
   }                                                                            \
-  int max_diff = 0;                                                            \
   /* Convert to a 3rd format in 1 step and 2 steps and compare  */             \
   const int kStrideC = kWidth * BPP_C;                                         \
   align_buffer_page_end(dst_argb_c, kStrideC * kHeight + OFF);                 \
diff --git a/unit_test/cpu_test.cc b/unit_test/cpu_test.cc
index 0cd06f9b7..97e74d0a8 100644
--- a/unit_test/cpu_test.cc
+++ b/unit_test/cpu_test.cc
@@ -96,7 +96,7 @@ TEST_F(LibYUVBaseTest, TestCpuId) {
     cpu_info[3] = 0;
     printf("Cpu Vendor: %s %x %x %x\n", reinterpret_cast<char*>(&cpu_info[0]),
            cpu_info[0], cpu_info[1], cpu_info[2]);
-    EXPECT_EQ(12, strlen(reinterpret_cast<char*>(&cpu_info[0])));
+    EXPECT_EQ(12u, strlen(reinterpret_cast<char*>(&cpu_info[0])));
 
     // CPU Family and Model
     // 3:0 - Stepping
diff --git a/unit_test/video_common_test.cc b/unit_test/video_common_test.cc
index 657f6a3d6..d2b049964 100644
--- a/unit_test/video_common_test.cc
+++ b/unit_test/video_common_test.cc
@@ -42,23 +42,23 @@ static bool TestValidFourCC(uint32 fourcc, int bpp) {
 }
 
 TEST_F(LibYUVBaseTest, TestCanonicalFourCC) {
-  EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_IYUV));
-  EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_YU12));
-  EXPECT_EQ(FOURCC_I422, CanonicalFourCC(FOURCC_YU16));
-  EXPECT_EQ(FOURCC_I444, CanonicalFourCC(FOURCC_YU24));
-  EXPECT_EQ(FOURCC_YUY2, CanonicalFourCC(FOURCC_YUYV));
-  EXPECT_EQ(FOURCC_YUY2, CanonicalFourCC(FOURCC_YUVS));
-  EXPECT_EQ(FOURCC_UYVY, CanonicalFourCC(FOURCC_HDYC));
-  EXPECT_EQ(FOURCC_UYVY, CanonicalFourCC(FOURCC_2VUY));
-  EXPECT_EQ(FOURCC_MJPG, CanonicalFourCC(FOURCC_JPEG));
-  EXPECT_EQ(FOURCC_MJPG, CanonicalFourCC(FOURCC_DMB1));
-  EXPECT_EQ(FOURCC_RAW,  CanonicalFourCC(FOURCC_RGB3));
-  EXPECT_EQ(FOURCC_24BG, CanonicalFourCC(FOURCC_BGR3));
-  EXPECT_EQ(FOURCC_BGRA, CanonicalFourCC(FOURCC_CM32));
-  EXPECT_EQ(FOURCC_RAW,  CanonicalFourCC(FOURCC_CM24));
-  EXPECT_EQ(FOURCC_RGBO, CanonicalFourCC(FOURCC_L555));
-  EXPECT_EQ(FOURCC_RGBP, CanonicalFourCC(FOURCC_L565));
-  EXPECT_EQ(FOURCC_RGBO, CanonicalFourCC(FOURCC_5551));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_I420), CanonicalFourCC(FOURCC_IYUV));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_I420), CanonicalFourCC(FOURCC_YU12));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_I422), CanonicalFourCC(FOURCC_YU16));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_I444), CanonicalFourCC(FOURCC_YU24));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUYV));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUVS));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_UYVY), CanonicalFourCC(FOURCC_HDYC));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_UYVY), CanonicalFourCC(FOURCC_2VUY));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_MJPG), CanonicalFourCC(FOURCC_JPEG));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_MJPG), CanonicalFourCC(FOURCC_DMB1));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_RAW),  CanonicalFourCC(FOURCC_RGB3));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_24BG), CanonicalFourCC(FOURCC_BGR3));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_BGRA), CanonicalFourCC(FOURCC_CM32));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_RAW),  CanonicalFourCC(FOURCC_CM24));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_RGBO), CanonicalFourCC(FOURCC_L555));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_RGBP), CanonicalFourCC(FOURCC_L565));
+  EXPECT_EQ(static_cast<uint32>(FOURCC_RGBO), CanonicalFourCC(FOURCC_5551));
 }
 
 TEST_F(LibYUVBaseTest, TestFourCC) {