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

talk/media/base/videoframe.cc

 /*
  * libjingle
  * Copyright 2011 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 26 matching lines @@
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
 // Round to 2 pixels because Chroma channels are half size.
 #define ROUNDTO2(v) (v & ~1)
 
 rtc::StreamResult VideoFrame::Write(rtc::StreamInterface* stream,
                                           int* error) const {
   rtc::StreamResult result = rtc::SR_SUCCESS;
-  const uint8* src_y = GetYPlane();
-  const uint8* src_u = GetUPlane();
-  const uint8* src_v = GetVPlane();
+  const uint8_t* src_y = GetYPlane();
+  const uint8_t* src_u = GetUPlane();
+  const uint8_t* src_v = GetVPlane();
   if (!src_y || !src_u || !src_v) {
     return result;  // Nothing to write.
   }
-  const int32 y_pitch = GetYPitch();
-  const int32 u_pitch = GetUPitch();
-  const int32 v_pitch = GetVPitch();
+  const int32_t y_pitch = GetYPitch();
+  const int32_t u_pitch = GetUPitch();
+  const int32_t v_pitch = GetVPitch();
   const size_t width = GetWidth();
   const size_t height = GetHeight();
   const size_t half_width = (width + 1) >> 1;
   const size_t half_height = (height + 1) >> 1;
   // Write Y.
   for (size_t row = 0; row < height; ++row) {
     result = stream->Write(src_y + row * y_pitch, width, NULL, error);
     if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
   // Write U.
   for (size_t row = 0; row < half_height; ++row) {
     result = stream->Write(src_u + row * u_pitch, half_width, NULL, error);
     if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
   // Write V.
   for (size_t row = 0; row < half_height; ++row) {
     result = stream->Write(src_v + row * v_pitch, half_width, NULL, error);
     if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
   return result;
 }
 
-size_t VideoFrame::CopyToBuffer(uint8* buffer, size_t size) const {
+size_t VideoFrame::CopyToBuffer(uint8_t* buffer, size_t size) const {
   const size_t y_size = GetHeight() * GetYPitch();
   const size_t u_size = GetUPitch() * GetChromaHeight();
   const size_t v_size = GetVPitch() * GetChromaHeight();
   const size_t needed = y_size + u_size + v_size;
   if (size < needed)
     return needed;
   CopyToPlanes(buffer, buffer + y_size, buffer + y_size + u_size,
                GetYPitch(), GetUPitch(), GetVPitch());
   return needed;
 }
 
-bool VideoFrame::CopyToPlanes(
-    uint8* dst_y, uint8* dst_u, uint8* dst_v,
-    int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v) const {
+bool VideoFrame::CopyToPlanes(uint8_t* dst_y,
+                              uint8_t* dst_u,
+                              uint8_t* dst_v,
+                              int32_t dst_pitch_y,
+                              int32_t dst_pitch_u,
+                              int32_t dst_pitch_v) const {
   if (!GetYPlane() || !GetUPlane() || !GetVPlane()) {
     LOG(LS_ERROR) << "NULL plane pointer.";
     return false;
   }
-  int32 src_width = static_cast<int>(GetWidth());
-  int32 src_height = static_cast<int>(GetHeight());
+  int32_t src_width = static_cast<int>(GetWidth());
+  int32_t src_height = static_cast<int>(GetHeight());
   return libyuv::I420Copy(GetYPlane(), GetYPitch(),
                           GetUPlane(), GetUPitch(),
                           GetVPlane(), GetVPitch(),
                           dst_y, dst_pitch_y,
                           dst_u, dst_pitch_u,
                           dst_v, dst_pitch_v,
                           src_width, src_height) == 0;
 }
 
 void VideoFrame::CopyToFrame(VideoFrame* dst) const {
   if (!dst) {
     LOG(LS_ERROR) << "NULL dst pointer.";
     return;
   }
 
   CopyToPlanes(dst->GetYPlane(), dst->GetUPlane(), dst->GetVPlane(),
                dst->GetYPitch(), dst->GetUPitch(), dst->GetVPitch());
 }
 
-size_t VideoFrame::ConvertToRgbBuffer(uint32 to_fourcc,
-                                      uint8* buffer,
+size_t VideoFrame::ConvertToRgbBuffer(uint32_t to_fourcc,
+                                      uint8_t* buffer,
                                       size_t size,
                                       int stride_rgb) const {
   const size_t needed = std::abs(stride_rgb) * GetHeight();
   if (size < needed) {
     LOG(LS_WARNING) << "RGB buffer is not large enough";
     return needed;
   }
 
   if (libyuv::ConvertFromI420(GetYPlane(), GetYPitch(), GetUPlane(),
                               GetUPitch(), GetVPlane(), GetVPitch(), buffer,
                               stride_rgb, static_cast<int>(GetWidth()),
                               static_cast<int>(GetHeight()), to_fourcc)) {
     LOG(LS_ERROR) << "RGB type not supported: " << to_fourcc;
     return 0;  // 0 indicates error
   }
   return needed;
 }
 
 // TODO(fbarchard): Handle odd width/height with rounding.
-void VideoFrame::StretchToPlanes(
-    uint8* dst_y, uint8* dst_u, uint8* dst_v,
-    int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
-    size_t width, size_t height, bool interpolate, bool vert_crop) const {
+void VideoFrame::StretchToPlanes(uint8_t* dst_y,
+                                 uint8_t* dst_u,
+                                 uint8_t* dst_v,
+                                 int32_t dst_pitch_y,
+                                 int32_t dst_pitch_u,
+                                 int32_t dst_pitch_v,
+                                 size_t width,
+                                 size_t height,
+                                 bool interpolate,
+                                 bool vert_crop) const {
   if (!GetYPlane() || !GetUPlane() || !GetVPlane()) {
     LOG(LS_ERROR) << "NULL plane pointer.";
     return;
   }
 
   size_t src_width = GetWidth();
   size_t src_height = GetHeight();
   if (width == src_width && height == src_height) {
     CopyToPlanes(dst_y, dst_u, dst_v, dst_pitch_y, dst_pitch_u, dst_pitch_v);
     return;
   }
-  const uint8* src_y = GetYPlane();
-  const uint8* src_u = GetUPlane();
-  const uint8* src_v = GetVPlane();
+  const uint8_t* src_y = GetYPlane();
+  const uint8_t* src_u = GetUPlane();
+  const uint8_t* src_v = GetVPlane();
 
   if (vert_crop) {
     // Adjust the input width:height ratio to be the same as the output ratio.
     if (src_width * height > src_height * width) {
       // Reduce the input width, but keep size/position aligned for YuvScaler
       src_width = ROUNDTO2(src_height * width / height);
-      int32 iwidth_offset = ROUNDTO2((GetWidth() - src_width) / 2);
+      int32_t iwidth_offset = ROUNDTO2((GetWidth() - src_width) / 2);
       src_y += iwidth_offset;
       src_u += iwidth_offset / 2;
       src_v += iwidth_offset / 2;
     } else if (src_width * height < src_height * width) {
       // Reduce the input height.
       src_height = src_width * height / width;
-      int32 iheight_offset = static_cast<int32>(
-          (GetHeight() - src_height) >> 2);
+      int32_t iheight_offset =
+          static_cast<int32_t>((GetHeight() - src_height) >> 2);
       iheight_offset <<= 1;  // Ensure that iheight_offset is even.
       src_y += iheight_offset * GetYPitch();
       src_u += iheight_offset / 2 * GetUPitch();
       src_v += iheight_offset / 2 * GetVPitch();
     }
   }
 
   // Scale to the output I420 frame.
   libyuv::Scale(src_y, src_u, src_v,
                 GetYPitch(), GetUPitch(), GetVPitch(),
@@ skipping 36 matching lines @@
                           GetUPlane(), GetUPitch(),
                           GetVPlane(), GetVPitch(),
                           0, 0,
                           static_cast<int>(GetWidth()),
                           static_cast<int>(GetHeight()),
                           16, 128, 128) == 0;
 }
 
 static const size_t kMaxSampleSize = 1000000000u;
 // Returns whether a sample is valid.
-bool VideoFrame::Validate(uint32 fourcc, int w, int h,
-                          const uint8 *sample, size_t sample_size) {
+bool VideoFrame::Validate(uint32_t fourcc,
+                          int w,
+                          int h,
+                          const uint8_t* sample,
+                          size_t sample_size) {
   if (h < 0) {
     h = -h;
   }
   // 16384 is maximum resolution for VP8 codec.
   if (w < 1 || w > 16384 || h < 1 || h > 16384) {
     LOG(LS_ERROR) << "Invalid dimensions: " << w << "x" << h;
     return false;
   }
-  uint32 format = CanonicalFourCC(fourcc);
+  uint32_t format = CanonicalFourCC(fourcc);
   int expected_bpp = 8;
   switch (format) {
     case FOURCC_I400:
     case FOURCC_RGGB:
     case FOURCC_BGGR:
     case FOURCC_GRBG:
     case FOURCC_GBRG:
       expected_bpp = 8;
       break;
     case FOURCC_I420:
@@ skipping 44 matching lines @@
   if (sample == NULL) {
     LOG(LS_ERROR) << "NULL sample pointer."
                   << " format: " << GetFourccName(format)
                   << " bpp: " << expected_bpp
                   << " size: " << w << "x" << h
                   << " expected: " << expected_size
                   << " " << sample_size;
     return false;
   }
   // TODO(fbarchard): Make function to dump information about frames.
-  uint8 four_samples[4] = { 0, 0, 0, 0 };
+  uint8_t four_samples[4] = {0, 0, 0, 0};
   for (size_t i = 0; i < ARRAY_SIZE(four_samples) && i < sample_size; ++i) {
     four_samples[i] = sample[i];
   }
   if (sample_size < expected_size) {
     LOG(LS_ERROR) << "Size field is too small."
                   << " format: " << GetFourccName(format)
                   << " bpp: " << expected_bpp
                   << " size: " << w << "x" << h
                   << " " << sample_size
                   << " expected: " << expected_size
@@ skipping 49 matching lines @@
                  << " expected: " << expected_size
                  << " sample[0..3]: " << static_cast<int>(four_samples[0])
                  << ", " << static_cast<int>(four_samples[1])
                  << ", " << static_cast<int>(four_samples[2])
                  << ", " << static_cast<int>(four_samples[3]);
   }
   return true;
 }
 
 }  // namespace cricket