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

talk/media/devices/filevideocapturer.cc

 /*
  * libjingle
  * Copyright 2004 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 42 matching lines @@
 void VideoRecorder::Stop() {
   video_file_.Close();
 }
 
 bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
   if (rtc::SS_CLOSED == video_file_.GetState()) {
     LOG(LS_ERROR) << "File not opened yet";
     return false;
   }
 
-  uint32 size = 0;
+  uint32_t size = 0;
   if (!frame.GetDataSize(&size)) {
     LOG(LS_ERROR) << "Unable to calculate the data size of the frame";
     return false;
   }
 
   if (write_header_) {
     // Convert the frame header to bytebuffer.
     rtc::ByteBuffer buffer;
     buffer.WriteUInt32(frame.width);
     buffer.WriteUInt32(frame.height);
@@ skipping 77 matching lines @@
   FileVideoCapturer* capturer_;
   mutable rtc::CriticalSection crit_;
   bool finished_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(FileReadThread);
 };
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of class FileVideoCapturer
 /////////////////////////////////////////////////////////////////////
-static const int64 kNumNanoSecsPerMilliSec = 1000000;
+static const int64_t kNumNanoSecsPerMilliSec = 1000000;
 const char* FileVideoCapturer::kVideoFileDevicePrefix = "video-file:";
 
 FileVideoCapturer::FileVideoCapturer()
     : frame_buffer_size_(0),
       file_read_thread_(NULL),
       repeat_(0),
       last_frame_timestamp_ns_(0),
       ignore_framerate_(false) {
 }
 
@@ skipping 88 matching lines @@
 
 void FileVideoCapturer::Stop() {
   if (file_read_thread_) {
     file_read_thread_->Stop();
     file_read_thread_ = NULL;
     LOG(LS_INFO) << "File video capturer '" << GetId() << "' stopped";
   }
   SetCaptureFormat(NULL);
 }
 
-bool FileVideoCapturer::GetPreferredFourccs(std::vector<uint32>* fourccs) {
+bool FileVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
   if (!fourccs) {
     return false;
   }
 
   fourccs->push_back(GetSupportedFormats()->at(0).fourcc);
   return true;
 }
 
 rtc::StreamResult FileVideoCapturer::ReadFrameHeader(
     CapturedFrame* frame) {
   // We first read kFrameHeaderSize bytes from the file stream to a memory
   // buffer, then construct a bytebuffer from the memory buffer, and finally
   // read the frame header from the bytebuffer.
   char header[CapturedFrame::kFrameHeaderSize];
   rtc::StreamResult sr;
   size_t bytes_read;
   int error;
   sr = video_file_.Read(header,
                         CapturedFrame::kFrameHeaderSize,
                         &bytes_read,
                         &error);
   LOG(LS_VERBOSE) << "Read frame header: stream_result = " << sr
                   << ", bytes read = " << bytes_read << ", error = " << error;
   if (rtc::SR_SUCCESS == sr) {
     if (CapturedFrame::kFrameHeaderSize != bytes_read) {
       return rtc::SR_EOS;
     }
     rtc::ByteBuffer buffer(header, CapturedFrame::kFrameHeaderSize);
-    buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->width));
-    buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->height));
+    buffer.ReadUInt32(reinterpret_cast<uint32_t*>(&frame->width));
+    buffer.ReadUInt32(reinterpret_cast<uint32_t*>(&frame->height));
     buffer.ReadUInt32(&frame->fourcc);
     buffer.ReadUInt32(&frame->pixel_width);
     buffer.ReadUInt32(&frame->pixel_height);
     // Elapsed time is deprecated.
-    uint64 dummy_elapsed_time;
+    uint64_t dummy_elapsed_time;
     buffer.ReadUInt64(&dummy_elapsed_time);
-    buffer.ReadUInt64(reinterpret_cast<uint64*>(&frame->time_stamp));
+    buffer.ReadUInt64(reinterpret_cast<uint64_t*>(&frame->time_stamp));
     buffer.ReadUInt32(&frame->data_size);
   }
 
   return sr;
 }
 
 // Executed in the context of FileReadThread.
 bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
-  uint32 start_read_time_ms = rtc::Time();
+  uint32_t start_read_time_ms = rtc::Time();
 
   // 1. Signal the previously read frame to downstream.
   if (!first_frame) {
-    captured_frame_.time_stamp = kNumNanoSecsPerMilliSec *
-        static_cast<int64>(start_read_time_ms);
+    captured_frame_.time_stamp =
+        kNumNanoSecsPerMilliSec * static_cast<int64_t>(start_read_time_ms);
     SignalFrameCaptured(this, &captured_frame_);
   }
 
   // 2. Read the next frame.
   if (rtc::SS_CLOSED == video_file_.GetState()) {
     LOG(LS_ERROR) << "File not opened yet";
     return false;
   }
   // 2.1 Read the frame header.
   rtc::StreamResult result = ReadFrameHeader(&captured_frame_);
@@ skipping 28 matching lines @@
     return false;
   }
 
   // 3. Decide how long to wait for the next frame.
   *wait_time_ms = 0;
 
   // If the capture format's interval is not kMinimumInterval, we use it to
   // control the rate; otherwise, we use the timestamp in the file to control
   // the rate.
   if (!first_frame && !ignore_framerate_) {
-    int64 interval_ns =
-        GetCaptureFormat()->interval > VideoFormat::kMinimumInterval ?
-        GetCaptureFormat()->interval :
-        captured_frame_.time_stamp - last_frame_timestamp_ns_;
+    int64_t interval_ns =
+        GetCaptureFormat()->interval > VideoFormat::kMinimumInterval
+            ? GetCaptureFormat()->interval
+            : captured_frame_.time_stamp - last_frame_timestamp_ns_;
     int interval_ms = static_cast<int>(interval_ns / kNumNanoSecsPerMilliSec);
     interval_ms -= rtc::Time() - start_read_time_ms;
     if (interval_ms > 0) {
       *wait_time_ms = interval_ms;
     }
   }
   // Keep the original timestamp read from the file.
   last_frame_timestamp_ns_ = captured_frame_.time_stamp;
   return true;
 }
 
 }  // namespace cricket