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

talk/media/webrtc/webrtcvideoframe.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 51 matching lines @@
     int64_t time_stamp_ns)
     : video_frame_buffer_(buffer),
       pixel_width_(1),
       pixel_height_(1),
       time_stamp_ns_(time_stamp_ns),
       rotation_(webrtc::kVideoRotation_0) {
 }
 
 WebRtcVideoFrame::~WebRtcVideoFrame() {}
 
-bool WebRtcVideoFrame::Init(uint32 format,
+bool WebRtcVideoFrame::Init(uint32_t format,
                             int w,
                             int h,
                             int dw,
                             int dh,
-                            uint8* sample,
+                            uint8_t* sample,
                             size_t sample_size,
                             size_t pixel_width,
                             size_t pixel_height,
                             int64_t time_stamp_ns,
                             webrtc::VideoRotation rotation) {
   return Reset(format, w, h, dw, dh, sample, sample_size, pixel_width,
                pixel_height, time_stamp_ns, rotation,
                true /*apply_rotation*/);
 }
 
 bool WebRtcVideoFrame::Init(const CapturedFrame* frame, int dw, int dh,
                             bool apply_rotation) {
   return Reset(frame->fourcc, frame->width, frame->height, dw, dh,
-               static_cast<uint8*>(frame->data), frame->data_size,
-               frame->pixel_width, frame->pixel_height,
-               frame->time_stamp,
-               frame->GetRotation(),
-               apply_rotation);
+               static_cast<uint8_t*>(frame->data), frame->data_size,
+               frame->pixel_width, frame->pixel_height, frame->time_stamp,
+               frame->GetRotation(), apply_rotation);
 }
 
 bool WebRtcVideoFrame::InitToBlack(int w, int h, size_t pixel_width,
                                    size_t pixel_height, int64_t,
                                    int64_t time_stamp_ns) {
   return InitToBlack(w, h, pixel_width, pixel_height, time_stamp_ns);
 }
 
 bool WebRtcVideoFrame::InitToBlack(int w, int h, size_t pixel_width,
                                    size_t pixel_height, int64_t time_stamp_ns) {
   InitToEmptyBuffer(w, h, pixel_width, pixel_height, time_stamp_ns);
   return SetToBlack();
 }
 
 size_t WebRtcVideoFrame::GetWidth() const {
   return video_frame_buffer_ ? video_frame_buffer_->width() : 0;
 }
 
 size_t WebRtcVideoFrame::GetHeight() const {
   return video_frame_buffer_ ? video_frame_buffer_->height() : 0;
 }
 
-const uint8* WebRtcVideoFrame::GetYPlane() const {
+const uint8_t* WebRtcVideoFrame::GetYPlane() const {
   return video_frame_buffer_ ? video_frame_buffer_->data(kYPlane) : nullptr;
 }
 
-const uint8* WebRtcVideoFrame::GetUPlane() const {
+const uint8_t* WebRtcVideoFrame::GetUPlane() const {
   return video_frame_buffer_ ? video_frame_buffer_->data(kUPlane) : nullptr;
 }
 
-const uint8* WebRtcVideoFrame::GetVPlane() const {
+const uint8_t* WebRtcVideoFrame::GetVPlane() const {
   return video_frame_buffer_ ? video_frame_buffer_->data(kVPlane) : nullptr;
 }
 
-uint8* WebRtcVideoFrame::GetYPlane() {
+uint8_t* WebRtcVideoFrame::GetYPlane() {
   return video_frame_buffer_ ? video_frame_buffer_->MutableData(kYPlane)
                              : nullptr;
 }
 
-uint8* WebRtcVideoFrame::GetUPlane() {
+uint8_t* WebRtcVideoFrame::GetUPlane() {
   return video_frame_buffer_ ? video_frame_buffer_->MutableData(kUPlane)
                              : nullptr;
 }
 
-uint8* WebRtcVideoFrame::GetVPlane() {
+uint8_t* WebRtcVideoFrame::GetVPlane() {
   return video_frame_buffer_ ? video_frame_buffer_->MutableData(kVPlane)
                              : nullptr;
 }
 
-int32 WebRtcVideoFrame::GetYPitch() const {
+int32_t WebRtcVideoFrame::GetYPitch() const {
   return video_frame_buffer_ ? video_frame_buffer_->stride(kYPlane) : 0;
 }
 
-int32 WebRtcVideoFrame::GetUPitch() const {
+int32_t WebRtcVideoFrame::GetUPitch() const {
   return video_frame_buffer_ ? video_frame_buffer_->stride(kUPlane) : 0;
 }
 
-int32 WebRtcVideoFrame::GetVPitch() const {
+int32_t WebRtcVideoFrame::GetVPitch() const {
   return video_frame_buffer_ ? video_frame_buffer_->stride(kVPlane) : 0;
 }
 
 bool WebRtcVideoFrame::IsExclusive() const {
   return video_frame_buffer_->HasOneRef();
 }
 
 void* WebRtcVideoFrame::GetNativeHandle() const {
   return video_frame_buffer_ ? video_frame_buffer_->native_handle() : nullptr;
 }
@@ skipping 28 matching lines @@
           new_buffer->MutableData(kYPlane), new_buffer->MutableData(kUPlane),
           new_buffer->MutableData(kVPlane), new_buffer->stride(kYPlane),
           new_buffer->stride(kUPlane), new_buffer->stride(kVPlane))) {
     return false;
   }
 
   video_frame_buffer_ = new_buffer;
   return true;
 }
 
-size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc, uint8* buffer,
-                                            size_t size, int stride_rgb) const {
+size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32_t to_fourcc,
+                                            uint8_t* buffer,
+                                            size_t size,
+                                            int stride_rgb) const {
   RTC_CHECK(video_frame_buffer_);
   RTC_CHECK(video_frame_buffer_->native_handle() == nullptr);
   return VideoFrame::ConvertToRgbBuffer(to_fourcc, buffer, size, stride_rgb);
 }
 
-bool WebRtcVideoFrame::Reset(uint32 format,
+bool WebRtcVideoFrame::Reset(uint32_t format,
                              int w,
                              int h,
                              int dw,
                              int dh,
-                             uint8* sample,
+                             uint8_t* sample,
                              size_t sample_size,
                              size_t pixel_width,
                              size_t pixel_height,
                              int64_t time_stamp_ns,
                              webrtc::VideoRotation rotation,
                              bool apply_rotation) {
   if (!Validate(format, w, h, sample, sample_size)) {
     return false;
   }
   // Translate aliases to standard enums (e.g., IYUV -> I420).
@@ skipping 95 matching lines @@
       rotated_frame_->GetUPlane(), rotated_frame_->GetUPitch(),
       rotated_frame_->GetVPlane(), rotated_frame_->GetVPitch(), width, height,
       static_cast<libyuv::RotationMode>(GetVideoRotation()));
   if (ret == 0) {
     return rotated_frame_.get();
   }
   return nullptr;
 }
 
 }  // namespace cricket