Switch to standard integer types in media/.

media/audio/cras/cras_input.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/cras/cras_input.h"
 
 #include <math.h>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/cras/audio_manager_cras.h"
 
 namespace media {
 
 CrasInputStream::CrasInputStream(const AudioParameters& params,
                                  AudioManagerCras* manager,
                                  const std::string& device_id)
@@ skipping 136 matching lines @@
       params_.channels());
   if (!audio_format) {
     DLOG(WARNING) << "Error setting up audio parameters.";
     callback_->OnError(this);
     callback_ = NULL;
     return;
   }
 
   // Initialize channel layout to all -1 to indicate that none of
   // the channels is set in the layout.
-  int8 layout[CRAS_CH_MAX];
+  int8_t layout[CRAS_CH_MAX];
   for (size_t i = 0; i < arraysize(layout); ++i)
     layout[i] = -1;
 
   // Converts to CRAS defined channels. ChannelOrder will return -1
   // for channels that are not present in params_.channel_layout().
   for (size_t i = 0; i < arraysize(kChannelMap); ++i) {
     layout[kChannelMap[i]] = ChannelOrder(params_.channel_layout(),
                                           static_cast<Channels>(i));
   }
   if (cras_audio_format_set_channel_layout(audio_format, layout) != 0) {
@@ skipping 56 matching lines @@
   // Removing the stream from the client stops audio.
   cras_client_rm_stream(client_, stream_id_);
 
   started_ = false;
   callback_ = NULL;
 }
 
 // Static callback asking for samples.  Run on high priority thread.
 int CrasInputStream::SamplesReady(cras_client* client,
                                   cras_stream_id_t stream_id,
-                                  uint8* samples,
+                                  uint8_t* samples,
                                   size_t frames,
                                   const timespec* sample_ts,
                                   void* arg) {
   CrasInputStream* me = static_cast<CrasInputStream*>(arg);
   me->ReadAudio(frames, samples, sample_ts);
   return frames;
 }
 
 // Static callback for stream errors.
 int CrasInputStream::StreamError(cras_client* client,
                                  cras_stream_id_t stream_id,
                                  int err,
                                  void* arg) {
   CrasInputStream* me = static_cast<CrasInputStream*>(arg);
   me->NotifyStreamError(err);
   return 0;
 }
 
 void CrasInputStream::ReadAudio(size_t frames,
-                                uint8* buffer,
+                                uint8_t* buffer,
                                 const timespec* sample_ts) {
   DCHECK(callback_);
 
   timespec latency_ts = {0, 0};
 
   // Determine latency and pass that on to the sink.  sample_ts is the wall time
   // indicating when the first sample in the buffer was captured.  Convert that
   // to latency in bytes.
   cras_client_calc_capture_latency(sample_ts, &latency_ts);
   double latency_usec =
@@ skipping 58 matching lines @@
 
 double CrasInputStream::GetVolumeRatioFromDecibels(double dB) const {
   return pow(10, dB / 20.0);
 }
 
 double CrasInputStream::GetDecibelsFromVolumeRatio(double volume_ratio) const {
   return 20 * log10(volume_ratio);
 }
 
 }  // namespace media