Switch to standard integer types in media/.

media/cast/test/receiver.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <deque>
 #include <map>
@@ skipping 47 matching lines @@
 #define DEFAULT_AUDIO_PAYLOAD_TYPE "127"
 #define DEFAULT_VIDEO_FEEDBACK_SSRC "12"
 #define DEFAULT_VIDEO_INCOMING_SSRC "11"
 #define DEFAULT_VIDEO_PAYLOAD_TYPE "96"
 
 #if defined(USE_X11)
 const char* kVideoWindowWidth = "1280";
 const char* kVideoWindowHeight = "720";
 #endif  // defined(USE_X11)
 
-void GetPorts(uint16* tx_port, uint16* rx_port) {
+void GetPorts(uint16_t* tx_port, uint16_t* rx_port) {
   test::InputBuilder tx_input(
       "Enter send port.", DEFAULT_SEND_PORT, 1, 65535);
-  *tx_port = static_cast<uint16>(tx_input.GetIntInput());
+  *tx_port = static_cast<uint16_t>(tx_input.GetIntInput());
 
   test::InputBuilder rx_input(
       "Enter receive port.", DEFAULT_RECEIVE_PORT, 1, 65535);
-  *rx_port = static_cast<uint16>(rx_input.GetIntInput());
+  *rx_port = static_cast<uint16_t>(rx_input.GetIntInput());
 }
 
 std::string GetIpAddress(const std::string& display_text) {
   test::InputBuilder input(display_text, DEFAULT_SEND_IP, INT_MIN, INT_MAX);
   std::string ip_address = input.GetStringInput();
   // Ensure IP address is either the default value or in correct form.
   while (ip_address != DEFAULT_SEND_IP &&
          std::count(ip_address.begin(), ip_address.end(), '.') != 3) {
     ip_address = input.GetStringInput();
   }
@@ skipping 180 matching lines @@
   // InProcessReceiver finals.
 
   void OnVideoFrame(const scoped_refptr<VideoFrame>& video_frame,
                     const base::TimeTicks& playout_time,
                     bool is_continuous) final {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
     LOG_IF(WARNING, !is_continuous)
         << "Video: Discontinuity in received frames.";
     video_playout_queue_.push_back(std::make_pair(playout_time, video_frame));
     ScheduleVideoPlayout();
-    uint16 frame_no;
+    uint16_t frame_no;
     if (media::cast::test::DecodeBarcode(video_frame, &frame_no)) {
       video_play_times_.insert(
-          std::pair<uint16, base::TimeTicks>(frame_no, playout_time));
+          std::pair<uint16_t, base::TimeTicks>(frame_no, playout_time));
     } else {
       VLOG(2) << "Barcode decode failed!";
     }
   }
 
   void OnAudioFrame(scoped_ptr<AudioBus> audio_frame,
                     const base::TimeTicks& playout_time,
                     bool is_continuous) final {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
     LOG_IF(WARNING, !is_continuous)
         << "Audio: Discontinuity in received frames.";
     base::AutoLock auto_lock(audio_lock_);
-    uint16 frame_no;
+    uint16_t frame_no;
     if (media::cast::DecodeTimestamp(audio_frame->channel(0),
                                      audio_frame->frames(),
                                      &frame_no)) {
       // Since there are lots of audio packets with the same frame_no,
       // we really want to make sure that we get the playout_time from
       // the first one. If is_continous is true, then it's possible
       // that we already missed the first one.
       if (is_continuous && frame_no == last_audio_frame_no_ + 1) {
         audio_play_times_.insert(
-            std::pair<uint16, base::TimeTicks>(frame_no, playout_time));
+            std::pair<uint16_t, base::TimeTicks>(frame_no, playout_time));
       }
       last_audio_frame_no_ = frame_no;
     } else {
       VLOG(2) << "Audio decode failed!";
       last_audio_frame_no_ = -2;
     }
     audio_playout_queue_.push_back(
         std::make_pair(playout_time, audio_frame.release()));
   }
 
@@ skipping 156 matching lines @@
     audio_playout_queue_.pop_front();
     ++num_audio_frames_processed_;
     return ret.Pass();
   }
 
   void CheckAVSync() {
     if (video_play_times_.size() > 30 &&
         audio_play_times_.size() > 30) {
       size_t num_events = 0;
       base::TimeDelta delta;
-      std::map<uint16, base::TimeTicks>::iterator audio_iter, video_iter;
+      std::map<uint16_t, base::TimeTicks>::iterator audio_iter, video_iter;
       for (video_iter = video_play_times_.begin();
            video_iter != video_play_times_.end();
            ++video_iter) {
         audio_iter = audio_play_times_.find(video_iter->first);
         if (audio_iter != audio_play_times_.end()) {
           num_events++;
           // Positive values means audio is running behind video.
           delta += audio_iter->second - video_iter->second;
         }
       }
@@ skipping 20 matching lines @@
 #if defined(USE_X11)
   test::LinuxOutputWindow render_;
 #endif  // defined(USE_X11)
   scoped_ptr<AudioOutputStream> audio_output_stream_;
 
   // Video playout queue.
   typedef std::pair<base::TimeTicks, scoped_refptr<VideoFrame> >
       VideoQueueEntry;
   std::deque<VideoQueueEntry> video_playout_queue_;
   base::TimeTicks last_popped_video_playout_time_;
-  int64 num_video_frames_processed_;
+  int64_t num_video_frames_processed_;
 
   base::OneShotTimer video_playout_timer_;
 
   // Audio playout queue, synchronized by |audio_lock_|.
   base::Lock audio_lock_;
   typedef std::pair<base::TimeTicks, AudioBus*> AudioQueueEntry;
   std::deque<AudioQueueEntry> audio_playout_queue_;
   base::TimeTicks last_popped_audio_playout_time_;
-  int64 num_audio_frames_processed_;
+  int64_t num_audio_frames_processed_;
 
   // These must only be used on the audio thread calling OnMoreData().
   scoped_ptr<AudioBus> currently_playing_audio_frame_;
   int currently_playing_audio_frame_start_;
 
-  std::map<uint16, base::TimeTicks> audio_play_times_;
-  std::map<uint16, base::TimeTicks> video_play_times_;
-  int32 last_audio_frame_no_;
+  std::map<uint16_t, base::TimeTicks> audio_play_times_;
+  std::map<uint16_t, base::TimeTicks> video_play_times_;
+  int32_t last_audio_frame_no_;
 };
 
 }  // namespace cast
 }  // namespace media
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   base::CommandLine::Init(argc, argv);
   InitLogging(logging::LoggingSettings());
 
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::StandaloneCastEnvironment);
 
   // Start up Chromium audio system.
   media::FakeAudioLogFactory fake_audio_log_factory_;
   const scoped_ptr<media::AudioManager> audio_manager(
       media::AudioManager::Create(&fake_audio_log_factory_));
   CHECK(media::AudioManager::Get());
 
   media::cast::FrameReceiverConfig audio_config =
       media::cast::GetAudioReceiverConfig();
   media::cast::FrameReceiverConfig video_config =
       media::cast::GetVideoReceiverConfig();
 
   // Determine local and remote endpoints.
-  uint16 remote_port, local_port;
+  uint16_t remote_port, local_port;
   media::cast::GetPorts(&remote_port, &local_port);
   if (!local_port) {
     LOG(ERROR) << "Invalid local port.";
     return 1;
   }
   std::string remote_ip_address = media::cast::GetIpAddress("Enter remote IP.");
   std::string local_ip_address = media::cast::GetIpAddress("Enter local IP.");
   net::IPAddressNumber remote_ip_number;
   net::IPAddressNumber local_ip_number;
   if (!net::ParseIPLiteralToNumber(remote_ip_address, &remote_ip_number)) {
@@ skipping 19 matching lines @@
                                   audio_config,
                                   video_config,
                                   window_width,
                                   window_height);
   player.Start();
 
   base::MessageLoop().Run();  // Run forever (i.e., until SIGTERM).
   NOTREACHED();
   return 0;
 }