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

talk/app/webrtc/androidvideocapturer.cc

 /*
  * libjingle
  * Copyright 2015 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 32 matching lines @@
 class AndroidVideoCapturer::FrameFactory : public cricket::VideoFrameFactory {
  public:
   FrameFactory(const rtc::scoped_refptr<AndroidVideoCapturerDelegate>& delegate)
       : start_time_(rtc::TimeNanos()), delegate_(delegate) {
     // Create a CapturedFrame that only contains header information, not the
     // actual pixel data.
     captured_frame_.pixel_height = 1;
     captured_frame_.pixel_width = 1;
     captured_frame_.data = nullptr;
     captured_frame_.data_size = cricket::CapturedFrame::kUnknownDataSize;
-    captured_frame_.fourcc = static_cast<uint32>(cricket::FOURCC_ANY);
+    captured_frame_.fourcc = static_cast<uint32_t>(cricket::FOURCC_ANY);
   }
 
   void UpdateCapturedFrame(
       const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer,
       int rotation,
-      int64 time_stamp_in_ns) {
+      int64_t time_stamp_in_ns) {
     buffer_ = buffer;
     captured_frame_.width = buffer->width();
     captured_frame_.height = buffer->height();
     captured_frame_.elapsed_time = rtc::TimeNanos() - start_time_;
     captured_frame_.time_stamp = time_stamp_in_ns;
     captured_frame_.rotation = rotation;
   }
 
   void ClearCapturedFrame() {
     buffer_ = nullptr;
@@ skipping 17 matching lines @@
         ShallowCenterCrop(buffer_, dst_width, dst_height),
         captured_frame->elapsed_time, captured_frame->time_stamp,
         captured_frame->GetRotation()));
     // Caller takes ownership.
     // TODO(magjed): Change CreateAliasedFrame() to return a rtc::scoped_ptr.
     return apply_rotation_ ? frame->GetCopyWithRotationApplied()->Copy()
                            : frame.release();
   }
 
  private:
-  uint64 start_time_;
+  uint64_t start_time_;
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer_;
   cricket::CapturedFrame captured_frame_;
   rtc::scoped_refptr<AndroidVideoCapturerDelegate> delegate_;
 };
 
 AndroidVideoCapturer::AndroidVideoCapturer(
     const rtc::scoped_refptr<AndroidVideoCapturerDelegate>& delegate)
     : running_(false),
       delegate_(delegate),
       frame_factory_(NULL),
@@ skipping 58 matching lines @@
   delegate_->Stop();
   current_state_ = cricket::CS_STOPPED;
   SignalStateChange(this, current_state_);
 }
 
 bool AndroidVideoCapturer::IsRunning() {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   return running_;
 }
 
-bool AndroidVideoCapturer::GetPreferredFourccs(std::vector<uint32>* fourccs) {
+bool AndroidVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   fourccs->push_back(cricket::FOURCC_YV12);
   return true;
 }
 
 void AndroidVideoCapturer::OnCapturerStarted(bool success) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   cricket::CaptureState new_state =
       success ? cricket::CS_RUNNING : cricket::CS_FAILED;
   if (new_state == current_state_)
     return;
   current_state_ = new_state;
 
   // TODO(perkj): SetCaptureState can not be used since it posts to |thread_|.
   // But |thread_ | is currently just the thread that happened to create the
   // cricket::VideoCapturer.
   SignalStateChange(this, new_state);
 }
 
 void AndroidVideoCapturer::OnIncomingFrame(
     rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer,
     int rotation,
-    int64 time_stamp) {
+    int64_t time_stamp) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   frame_factory_->UpdateCapturedFrame(buffer, rotation, time_stamp);
   SignalFrameCaptured(this, frame_factory_->GetCapturedFrame());
   frame_factory_->ClearCapturedFrame();
 }
 
 void AndroidVideoCapturer::OnOutputFormatRequest(
     int width, int height, int fps) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   const cricket::VideoFormat& current = video_adapter()->output_format();
   cricket::VideoFormat format(
       width, height, cricket::VideoFormat::FpsToInterval(fps), current.fourcc);
   video_adapter()->OnOutputFormatRequest(format);
 }
 
 bool AndroidVideoCapturer::GetBestCaptureFormat(
     const cricket::VideoFormat& desired,
     cricket::VideoFormat* best_format) {
   // Delegate this choice to VideoCapturerAndroid.startCapture().
   *best_format = desired;
   return true;
 }
 
 }  // namespace webrtc