Switch to standard integer types in media/.

media/audio/win/audio_low_latency_output_win.cc

 // Copyright (c) 2012 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 "media/audio/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 422 matching lines @@
   if (mm_task && !avrt::AvRevertMmThreadCharacteristics(mm_task)) {
     PLOG(WARNING) << "Failed to disable MMCSS";
   }
 }
 
 bool WASAPIAudioOutputStream::RenderAudioFromSource(UINT64 device_frequency) {
   TRACE_EVENT0("audio", "RenderAudioFromSource");
 
   HRESULT hr = S_FALSE;
   UINT32 num_queued_frames = 0;
-  uint8* audio_data = NULL;
+  uint8_t* audio_data = NULL;
 
   // Contains how much new data we can write to the buffer without
   // the risk of overwriting previously written data that the audio
   // engine has not yet read from the buffer.
   size_t num_available_frames = 0;
 
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     // Get the padding value which represents the amount of rendering
     // data that is queued up to play in the endpoint buffer.
     hr = audio_client_->GetCurrentPadding(&num_queued_frames);
@@ skipping 48 matching lines @@
                  << std::hex << hr;
       return false;
     }
 
     // Derive the audio delay which corresponds to the delay between
     // a render event and the time when the first audio sample in a
     // packet is played out through the speaker. This delay value
     // can typically be utilized by an acoustic echo-control (AEC)
     // unit at the render side.
     UINT64 position = 0;
-    uint32 audio_delay_bytes = 0;
+    uint32_t audio_delay_bytes = 0;
     hr = audio_clock_->GetPosition(&position, NULL);
     if (SUCCEEDED(hr)) {
       // Stream position of the sample that is currently playing
       // through the speaker.
       double pos_sample_playing_frames = format_.Format.nSamplesPerSec *
           (static_cast<double>(position) / device_frequency);
 
       // Stream position of the last sample written to the endpoint
       // buffer. Note that, the packet we are about to receive in
       // the upcoming callback is also included.
       size_t pos_last_sample_written_frames =
           num_written_frames_ + packet_size_frames_;
 
       // Derive the actual delay value which will be fed to the
       // render client using the OnMoreData() callback.
       audio_delay_bytes = (pos_last_sample_written_frames -
           pos_sample_playing_frames) *  format_.Format.nBlockAlign;
     }
 
     // Read a data packet from the registered client source and
     // deliver a delay estimate in the same callback to the client.
 
     int frames_filled =
         source_->OnMoreData(audio_bus_.get(), audio_delay_bytes, 0);
-    uint32 num_filled_bytes = frames_filled * format_.Format.nBlockAlign;
+    uint32_t num_filled_bytes = frames_filled * format_.Format.nBlockAlign;
     DCHECK_LE(num_filled_bytes, packet_size_bytes_);
 
     // Note: If this ever changes to output raw float the data must be
     // clipped and sanitized since it may come from an untrusted
     // source such as NaCl.
     const int bytes_per_sample = format_.Format.wBitsPerSample >> 3;
     audio_bus_->Scale(volume_);
     audio_bus_->ToInterleaved(
         frames_filled, bytes_per_sample, audio_data);
 
     // Release the buffer space acquired in the GetBuffer() call.
     // Render silence if we were not able to fill up the buffer totally.
     DWORD flags = (num_filled_bytes < packet_size_bytes_) ?
         AUDCLNT_BUFFERFLAGS_SILENT : 0;
     audio_render_client_->ReleaseBuffer(packet_size_frames_, flags);
 
     num_written_frames_ += packet_size_frames_;
   }
 
   return true;
 }
 
 HRESULT WASAPIAudioOutputStream::ExclusiveModeInitialization(
-    IAudioClient* client, HANDLE event_handle, uint32* endpoint_buffer_size) {
+    IAudioClient* client,
+    HANDLE event_handle,
+    uint32_t* endpoint_buffer_size) {
   DCHECK_EQ(share_mode_, AUDCLNT_SHAREMODE_EXCLUSIVE);
 
   float f = (1000.0 * packet_size_frames_) / format_.Format.nSamplesPerSec;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(f * 10000.0 + 0.5);
 
   DWORD stream_flags = AUDCLNT_STREAMFLAGS_NOPERSIST;
   bool use_event = (event_handle != NULL &&
                     event_handle != INVALID_HANDLE_VALUE);
   if (use_event)
@@ skipping 76 matching lines @@
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media