Switch to standard integer types in media/.

media/audio/alsa/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 60 matching lines @@
 // based on the number of channels requested.  NULL is returned if no device
 // can be found to match the channel numbers.  In this case, using
 // kDefaultDevice is probably the best bet.
 //
 // A five channel source is assumed to be surround50 instead of surround41
 // (which is also 5 channels).
 //
 // TODO(ajwong): The source data should have enough info to tell us if we want
 // surround41 versus surround51, etc., instead of needing us to guess based on
 // channel number.  Fix API to pass that data down.
-static const char* GuessSpecificDeviceName(uint32 channels) {
+static const char* GuessSpecificDeviceName(uint32_t channels) {
   switch (channels) {
     case 8:
       return "surround71";
 
     case 7:
       return "surround70";
 
     case 6:
       return "surround51";
 
@@ skipping 32 matching lines @@
   };
   return os;
 }
 
 const char AlsaPcmOutputStream::kDefaultDevice[] = "default";
 const char AlsaPcmOutputStream::kAutoSelectDevice[] = "";
 const char AlsaPcmOutputStream::kPlugPrefix[] = "plug:";
 
 // We use 40ms as our minimum required latency. If it is needed, we may be able
 // to get it down to 20ms.
-const uint32 AlsaPcmOutputStream::kMinLatencyMicros = 40 * 1000;
+const uint32_t AlsaPcmOutputStream::kMinLatencyMicros = 40 * 1000;
 
 AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
                                          const AudioParameters& params,
                                          AlsaWrapper* wrapper,
                                          AudioManagerBase* manager)
     : requested_device_name_(device_name),
       pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample())),
       channels_(params.channels()),
       channel_layout_(params.channel_layout()),
       sample_rate_(params.sample_rate()),
@@ skipping 70 matching lines @@
 
   // Finish initializing the stream if the device was opened successfully.
   if (playback_handle_ == NULL) {
     stop_stream_ = true;
     TransitionTo(kInError);
     return false;
   }
   bytes_per_output_frame_ =
       channel_mixer_ ? mixed_audio_bus_->channels() * bytes_per_sample_
                      : bytes_per_frame_;
-  uint32 output_packet_size = frames_per_packet_ * bytes_per_output_frame_;
+  uint32_t output_packet_size = frames_per_packet_ * bytes_per_output_frame_;
   buffer_.reset(new media::SeekableBuffer(0, output_packet_size));
 
   // Get alsa buffer size.
   snd_pcm_uframes_t buffer_size;
   snd_pcm_uframes_t period_size;
   int error =
       wrapper_->PcmGetParams(playback_handle_, &buffer_size, &period_size);
   if (error < 0) {
     LOG(ERROR) << "Failed to get playback buffer size from ALSA: "
                << wrapper_->StrError(error);
@@ skipping 115 matching lines @@
     return;
   }
 
   *source_exhausted = false;
 
   // Request more data only when we run out of data in the buffer, because
   // WritePacket() consumes only the current chunk of data.
   if (!buffer_->forward_bytes()) {
     // Before making a request to source for data we need to determine the
     // delay (in bytes) for the requested data to be played.
-    const uint32 hardware_delay = GetCurrentDelay() * bytes_per_frame_;
+    const uint32_t hardware_delay = GetCurrentDelay() * bytes_per_frame_;
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
     int frames_filled = RunDataCallback(
         audio_bus_.get(), hardware_delay);
 
     size_t packet_size = frames_filled * bytes_per_frame_;
     DCHECK_LE(packet_size, packet_size_);
 
     // TODO(dalecurtis): Channel downmixing, upmixing, should be done in mixer;
@@ skipping 50 matching lines @@
   if (stop_stream_) {
     buffer_->Clear();
     return;
   }
 
   if (state() != kIsPlaying)
     return;
 
   CHECK_EQ(buffer_->forward_bytes() % bytes_per_output_frame_, 0u);
 
-  const uint8* buffer_data;
+  const uint8_t* buffer_data;
   int buffer_size;
   if (buffer_->GetCurrentChunk(&buffer_data, &buffer_size)) {
     snd_pcm_sframes_t frames = std::min(
         static_cast<snd_pcm_sframes_t>(buffer_size / bytes_per_output_frame_),
         GetAvailableFrames());
 
     if (!frames)
       return;
 
     snd_pcm_sframes_t frames_written =
@@ skipping 46 matching lines @@
 
   ScheduleNextWrite(source_exhausted);
 }
 
 void AlsaPcmOutputStream::ScheduleNextWrite(bool source_exhausted) {
   DCHECK(IsOnAudioThread());
 
   if (stop_stream_ || state() != kIsPlaying)
     return;
 
-  const uint32 kTargetFramesAvailable = alsa_buffer_frames_ / 2;
-  uint32 available_frames = GetAvailableFrames();
+  const uint32_t kTargetFramesAvailable = alsa_buffer_frames_ / 2;
+  uint32_t available_frames = GetAvailableFrames();
 
   base::TimeDelta next_fill_time;
   if (buffer_->forward_bytes() && available_frames) {
     // If we've got data available and ALSA has room, deliver it immediately.
     next_fill_time = base::TimeDelta();
   } else if (buffer_->forward_bytes()) {
     // If we've got data available and no room, poll until room is available.
     // Polling in this manner allows us to ensure a more consistent callback
     // schedule.  In testing this yields a variance of +/- 5ms versus the non-
     // polling strategy which is around +/- 30ms and bimodal.
@@ skipping 18 matching lines @@
       next_fill_time);
 }
 
 // static
 base::TimeDelta AlsaPcmOutputStream::FramesToTimeDelta(int frames,
                                                        double sample_rate) {
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
-std::string AlsaPcmOutputStream::FindDeviceForChannels(uint32 channels) {
+std::string AlsaPcmOutputStream::FindDeviceForChannels(uint32_t channels) {
   // Constants specified by the ALSA API for device hints.
   static const int kGetAllDevices = -1;
   static const char kPcmInterfaceName[] = "pcm";
   static const char kIoHintName[] = "IOID";
   static const char kNameHintName[] = "NAME";
 
   const char* wanted_device = GuessSpecificDeviceName(channels);
   if (!wanted_device)
     return std::string();
 
@@ skipping 85 matching lines @@
   if (available_frames < 0) {
     available_frames = wrapper_->PcmRecover(playback_handle_,
                                             available_frames,
                                             kPcmRecoverIsSilent);
   }
   if (available_frames < 0) {
     LOG(ERROR) << "Failed querying available frames. Assuming 0: "
                << wrapper_->StrError(available_frames);
     return 0;
   }
-  if (static_cast<uint32>(available_frames) > alsa_buffer_frames_ * 2) {
+  if (static_cast<uint32_t>(available_frames) > alsa_buffer_frames_ * 2) {
     LOG(ERROR) << "ALSA returned " << available_frames << " of "
                << alsa_buffer_frames_ << " frames available.";
     return alsa_buffer_frames_;
   }
 
   return available_frames;
 }
 
 snd_pcm_t* AlsaPcmOutputStream::AutoSelectDevice(unsigned int latency) {
   // For auto-selection:
@@ skipping 36 matching lines @@
                pcm_format_, latency)) != NULL) {
         return handle;
       }
     }
   }
 
   // For the kDefaultDevice device, we can only reliably depend on 2-channel
   // output to have the correct ordering according to Lennart.  For the channel
   // formats that we know how to downmix from (3 channel to 8 channel), setup
   // downmixing.
-  uint32 default_channels = channels_;
+  uint32_t default_channels = channels_;
   if (default_channels > 2) {
     channel_mixer_.reset(
         new ChannelMixer(channel_layout_, kDefaultOutputChannelLayout));
     default_channels = 2;
     mixed_audio_bus_ = AudioBus::Create(
         default_channels, audio_bus_->frames());
   }
 
   // Step 4.
   device_name_ = kDefaultDevice;
@@ skipping 57 matching lines @@
 
 AlsaPcmOutputStream::InternalState AlsaPcmOutputStream::state() {
   return state_;
 }
 
 bool AlsaPcmOutputStream::IsOnAudioThread() const {
   return message_loop_ && message_loop_ == base::MessageLoop::current();
 }
 
 int AlsaPcmOutputStream::RunDataCallback(AudioBus* audio_bus,
-                                         uint32 total_bytes_delay) {
+                                         uint32_t total_bytes_delay) {
   TRACE_EVENT0("audio", "AlsaPcmOutputStream::RunDataCallback");
 
   if (source_callback_)
     return source_callback_->OnMoreData(audio_bus, total_bytes_delay, 0);
 
   return 0;
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(IsOnAudioThread());
   source_callback_ = callback;
 }
 
 }  // namespace media