Use suffixed {uint,int}{8,16,32,64}_t types.

talk/session/media/yuvscaler_unittest.cc

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 47 matching lines @@
 // #define TEST_UNCACHED 1
 // #define TEST_RSTSC 1
 #endif
 
 #if defined(TEST_UNCACHED) || defined(TEST_RSTSC)
 #ifdef _MSC_VER
 #include <emmintrin.h>  // NOLINT
 #endif
 
 #if defined(__GNUC__) && defined(__i386__)
-static inline uint64 __rdtsc(void) {
+static inline uint64_t __rdtsc(void) {
   uint32_t a, d;
   __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
-  return (reinterpret_cast<uint64>(d) << 32) + a;
+  return (reinterpret_cast<uint64_t>(d) << 32) + a;
 }
 
 static inline void _mm_clflush(volatile void *__p) {
   asm volatile("clflush %0" : "+m" (*(volatile char *)__p));
 }
 #endif
 
-static void FlushCache(uint8* dst, int count) {
+static void FlushCache(uint8_t* dst, int count) {
   while (count >= 32) {
     _mm_clflush(dst);
     dst += 32;
     count -= 32;
   }
 }
 #endif
 
 class YuvScalerTest : public testing::Test {
  protected:
   virtual void SetUp() {
     dump_ = *rtc::FlagList::Lookup("yuvscaler_dump")->bool_variable();
     repeat_ = *rtc::FlagList::Lookup("yuvscaler_repeat")->int_variable();
   }
 
   // Scale an image and compare against a Lanczos-filtered test image.
   // Lanczos is considered to be the "ideal" image resampling method, so we try
   // to get as close to that as possible, while being as fast as possible.
   bool TestScale(int iw, int ih, int ow, int oh, int offset, bool usefile,
                  bool optimize, int cpuflags, bool interpolate,
                  int memoffset, double* error) {
     *error = 0.;
     size_t isize = I420_SIZE(iw, ih);
     size_t osize = I420_SIZE(ow, oh);
-    scoped_ptr<uint8[]> ibuffer(new uint8[isize + kAlignment + memoffset]());
-    scoped_ptr<uint8[]> obuffer(new uint8[osize + kAlignment + memoffset]());
-    scoped_ptr<uint8[]> xbuffer(new uint8[osize + kAlignment + memoffset]());
+    scoped_ptr<uint8_t[]> ibuffer(
+        new uint8_t[isize + kAlignment + memoffset]());
+    scoped_ptr<uint8_t[]> obuffer(
+        new uint8_t[osize + kAlignment + memoffset]());
+    scoped_ptr<uint8_t[]> xbuffer(
+        new uint8_t[osize + kAlignment + memoffset]());
 
-    uint8 *ibuf = ALIGNP(ibuffer.get(), kAlignment) + memoffset;
-    uint8 *obuf = ALIGNP(obuffer.get(), kAlignment) + memoffset;
-    uint8 *xbuf = ALIGNP(xbuffer.get(), kAlignment) + memoffset;
+    uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment) + memoffset;
+    uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment) + memoffset;
+    uint8_t* xbuf = ALIGNP(xbuffer.get(), kAlignment) + memoffset;
 
     if (usefile) {
       if (!LoadPlanarYuvTestImage("faces", iw, ih, ibuf) ||
           !LoadPlanarYuvTestImage("faces", ow, oh, xbuf)) {
         LOG(LS_ERROR) << "Failed to load image";
         return false;
       }
     } else {
       // These are used to test huge images.
       memset(ibuf, 213, isize);  // Input is constant color.
       memset(obuf, 100, osize);  // Output set to something wrong for now.
       memset(xbuf, 213, osize);  // Expected result.
     }
 
 #ifdef TEST_UNCACHED
     FlushCache(ibuf, isize);
     FlushCache(obuf, osize);
     FlushCache(xbuf, osize);
 #endif
 
     // Scale down.
     // If cpu true, disable cpu optimizations.  Else allow auto detect
     // TODO(fbarchard): set flags for libyuv
     libyuv::MaskCpuFlags(cpuflags);
 #ifdef TEST_RSTSC
-    uint64 t = 0;
+    uint64_t t = 0;
 #endif
     for (int i = 0; i < repeat_; ++i) {
 #ifdef TEST_UNCACHED
       FlushCache(ibuf, isize);
       FlushCache(obuf, osize);
 #endif
 #ifdef TEST_RSTSC
-      uint64 t1 = __rdtsc();
+      uint64_t t1 = __rdtsc();
 #endif
       EXPECT_EQ(0, libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh,
                                        offset, interpolate));
 #ifdef TEST_RSTSC
-      uint64 t2 = __rdtsc();
+      uint64_t t2 = __rdtsc();
       t += t2 - t1;
 #endif
     }
 
 #ifdef TEST_RSTSC
     LOG(LS_INFO) << "Time: " << std::setw(9) << t;
 #endif
 
     if (dump_) {
       const testing::TestInfo* const test_info =
           testing::UnitTest::GetInstance()->current_test_info();
       std::string test_name(test_info->name());
       DumpPlanarYuvTestImage(test_name, obuf, ow, oh);
     }
 
     double sse = cricket::ComputeSumSquareError(obuf, xbuf, osize);
     *error = sse / osize;  // Mean Squared Error.
     double PSNR = cricket::ComputePSNR(sse, osize);
     LOG(LS_INFO) << "Image MSE: " <<
       std::setw(6) << std::setprecision(4) << *error <<
       " Image PSNR: " << PSNR;
     return true;
   }
 
   // Returns the index of the first differing byte. Easier to debug than memcmp.
-  static int FindDiff(const uint8* buf1, const uint8* buf2, int len) {
+  static int FindDiff(const uint8_t* buf1, const uint8_t* buf2, int len) {
     int i = 0;
     while (i < len && buf1[i] == buf2[i]) {
       i++;
     }
     return (i < len) ? i : -1;
   }
 
  protected:
   bool dump_;
   int repeat_;
 };
 
 // Tests straight copy of data.
 TEST_F(YuvScalerTest, TestCopy) {
   const int iw = 640, ih = 360;
   const int ow = 640, oh = 360;
-  ALIGN16(uint8 ibuf[I420_SIZE(iw, ih)]);
-  ALIGN16(uint8 obuf[I420_SIZE(ow, oh)]);
+  ALIGN16(uint8_t ibuf[I420_SIZE(iw, ih)]);
+  ALIGN16(uint8_t obuf[I420_SIZE(ow, oh)]);
 
   // Load the frame, scale it, check it.
   ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf));
   for (int i = 0; i < repeat_; ++i) {
     libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, 0, false);
   }
   if (dump_) DumpPlanarYuvTestImage("TestCopy", obuf, ow, oh);
   EXPECT_EQ(-1, FindDiff(obuf, ibuf, sizeof(ibuf)));
 }
 
 // Tests copy from 4:3 to 16:9.
 TEST_F(YuvScalerTest, TestOffset16_10Copy) {
   const int iw = 640, ih = 360;
   const int ow = 640, oh = 480;
   const int offset = (480 - 360) / 2;
-  scoped_ptr<uint8[]> ibuffer(new uint8[I420_SIZE(iw, ih) + kAlignment]);
-  scoped_ptr<uint8[]> obuffer(new uint8[I420_SIZE(ow, oh) + kAlignment]);
+  scoped_ptr<uint8_t[]> ibuffer(new uint8_t[I420_SIZE(iw, ih) + kAlignment]);
+  scoped_ptr<uint8_t[]> obuffer(new uint8_t[I420_SIZE(ow, oh) + kAlignment]);
 
-  uint8 *ibuf = ALIGNP(ibuffer.get(), kAlignment);
-  uint8 *obuf = ALIGNP(obuffer.get(), kAlignment);
+  uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment);
+  uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment);
 
   // Load the frame, scale it, check it.
   ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf));
 
   // Clear to black, which is Y = 0 and U and V = 128
   memset(obuf, 0, ow * oh);
   memset(obuf + ow * oh, 128, ow * oh / 2);
   for (int i = 0; i < repeat_; ++i) {
     libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, offset, false);
   }
@@ skipping 382 matching lines @@
 TEST_H(TestScaleDown8xHDOptInt, 1280, 720, 1280 / 8, 720 / 8, true, ALLFLAGS,
        true, 1)
 
 // Tests interpolated 1/8x scale down, using optimized algorithm.
 TEST_H(TestScaleDown9xHDOptInt, 1280, 720, 1280 / 9, 720 / 9, true, ALLFLAGS,
        true, 1)
 
 // Tests interpolated 1/8x scale down, using optimized algorithm.
 TEST_H(TestScaleDown10xHDOptInt, 1280, 720, 1280 / 10, 720 / 10, true, ALLFLAGS,
        true, 1)