Make AudioParameters a class instead of a struct

content/renderer/media/webrtc_audio_device_impl.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 "content/renderer/media/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_hardware.h"
@@ skipping 14 matching lines @@
 // media::GetAudioInput[Output]HardwareSampleRate() is hardcoded to return
 // 48000 in both directions on Linux.
 static int kValidInputRates[] = {48000};
 static int kValidOutputRates[] = {48000};
 #endif
 
 WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()
     : ref_count_(0),
       render_loop_(base::MessageLoopProxy::current()),
       audio_transport_callback_(NULL),
-      input_buffer_size_(0),
-      output_buffer_size_(0),
-      input_channels_(0),
-      output_channels_(0),
-      input_sample_rate_(0),
-      output_sample_rate_(0),
       input_delay_ms_(0),
       output_delay_ms_(0),
       last_error_(AudioDeviceModule::kAdmErrNone),
       last_process_time_(base::TimeTicks::Now()),
       session_id_(0),
       bytes_per_sample_(0),
       initialized_(false),
       playing_(false),
       recording_(false) {
     DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
@@ skipping 20 matching lines @@
   if (ret == 0) {
     delete this;
   }
   return ret;
 }
 
 size_t WebRtcAudioDeviceImpl::Render(
     const std::vector<float*>& audio_data,
     size_t number_of_frames,
     size_t audio_delay_milliseconds) {
-  DCHECK_LE(number_of_frames, output_buffer_size_);
+  DCHECK_LE(number_of_frames, output_buffer_size());
 
   {
     base::AutoLock auto_lock(lock_);
     // Store the reported audio delay locally.
     output_delay_ms_ = audio_delay_milliseconds;
   }
 
   const int channels = audio_data.size();
-  DCHECK_LE(channels, output_channels_);
+  DCHECK_LE(channels, output_channels());
 
-  int samples_per_sec = static_cast<int>(output_sample_rate_);
+  int samples_per_sec = output_sample_rate();
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
   uint32_t samples_per_10_msec = (samples_per_sec / 100);
   const int bytes_per_10_msec =
       channels * samples_per_10_msec * bytes_per_sample_;
 
   uint32_t num_audio_samples = 0;
   size_t accumulated_audio_samples = 0;
@@ skipping 32 matching lines @@
 void WebRtcAudioDeviceImpl::OnRenderError() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // TODO(henrika): Implement error handling.
   LOG(ERROR) << "OnRenderError()";
 }
 
 void WebRtcAudioDeviceImpl::Capture(
     const std::vector<float*>& audio_data,
     size_t number_of_frames,
     size_t audio_delay_milliseconds) {
-  DCHECK_LE(number_of_frames, input_buffer_size_);
+  DCHECK_LE(number_of_frames, input_buffer_size());
 
   int output_delay_ms = 0;
   {
     base::AutoLock auto_lock(lock_);
     // Store the reported audio delay locally.
     input_delay_ms_ = audio_delay_milliseconds;
     output_delay_ms = output_delay_ms_;
   }
 
   const int channels = audio_data.size();
-  DCHECK_LE(channels, input_channels_);
+  DCHECK_LE(channels, input_channels());
   uint32_t new_mic_level = 0;
 
   // Interleave, scale, and clip input to int16 and store result in
   // a local byte buffer.
   media::InterleaveFloatToInt16(audio_data,
                                 input_buffer_.get(),
                                 number_of_frames);
 
-  int samples_per_sec = static_cast<int>(input_sample_rate_);
+  int samples_per_sec = input_sample_rate();
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
   const int samples_per_10_msec = (samples_per_sec / 100);
   const int bytes_per_10_msec =
       channels * samples_per_10_msec * bytes_per_sample_;
   size_t accumulated_audio_samples = 0;
 
   char* audio_byte_buffer = reinterpret_cast<char*>(input_buffer_.get());
@@ skipping 118 matching lines @@
   DCHECK(!audio_output_device_);
   DCHECK(!input_buffer_.get());
   DCHECK(!output_buffer_.get());
 
   // TODO(henrika): it could be possible to allow one of the directions (input
   // or output) to use a non-supported rate. As an example: if only the
   // output rate is OK, we could finalize Init() and only set up an AudioDevice.
 
   // Ask the browser for the default audio output hardware sample-rate.
   // This request is based on a synchronous IPC message.
-  int output_sample_rate =
-      static_cast<int>(audio_hardware::GetOutputSampleRate());
-  DVLOG(1) << "Audio output hardware sample rate: " << output_sample_rate;
+  int out_sample_rate = audio_hardware::GetOutputSampleRate();
+  DVLOG(1) << "Audio output hardware sample rate: " << out_sample_rate;
 
   // Verify that the reported output hardware sample rate is supported
   // on the current platform.
   if (std::find(&kValidOutputRates[0],
                 &kValidOutputRates[0] + arraysize(kValidOutputRates),
-                output_sample_rate) ==
+                out_sample_rate) ==
       &kValidOutputRates[arraysize(kValidOutputRates)]) {
-    DLOG(ERROR) << output_sample_rate << " is not a supported output rate.";
+    DLOG(ERROR) << out_sample_rate << " is not a supported output rate.";
     return -1;
   }
 
   // Ask the browser for the default audio input hardware sample-rate.
   // This request is based on a synchronous IPC message.
-  int input_sample_rate =
-      static_cast<int>(audio_hardware::GetInputSampleRate());
-  DVLOG(1) << "Audio input hardware sample rate: " << input_sample_rate;
+  int in_sample_rate = audio_hardware::GetInputSampleRate();
+  DVLOG(1) << "Audio input hardware sample rate: " << in_sample_rate;
 
   // Verify that the reported input hardware sample rate is supported
   // on the current platform.
   if (std::find(&kValidInputRates[0],
                 &kValidInputRates[0] + arraysize(kValidInputRates),
-                input_sample_rate) ==
+                in_sample_rate) ==
       &kValidInputRates[arraysize(kValidInputRates)]) {
-    DLOG(ERROR) << input_sample_rate << " is not a supported input rate.";
+    DLOG(ERROR) << in_sample_rate << " is not a supported input rate.";
     return -1;
   }
 
   // Ask the browser for the default number of audio input channels.
   // This request is based on a synchronous IPC message.
-  int input_channels = audio_hardware::GetInputChannelCount();
-  DVLOG(1) << "Audio input hardware channels: " << input_channels;
+  ChannelLayout input_channel_layout =
+      audio_hardware::GetInputChannelLayout();
+  DVLOG(1) << "Audio input hardware channels: " << input_channel_layout;
 
-  int output_channels = 0;
-
-  size_t input_buffer_size = 0;
-  size_t output_buffer_size = 0;
+  ChannelLayout out_channel_layout = CHANNEL_LAYOUT_MONO;
+  AudioParameters::Format in_format = AudioParameters::AUDIO_PCM_LINEAR;
+  size_t in_buffer_size = 0;
+  size_t out_buffer_size = 0;
 
   // TODO(henrika): factor out all platform specific parts in separate
   // functions. Code is a bit messy right now.
 
 // Windows
 #if defined(OS_WIN)
   // Always use stereo rendering on Windows.
-  output_channels = 2;
+  out_channel_layout = CHANNEL_LAYOUT_STEREO;
+
+  DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
+  in_format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 
   // Capture side: AUDIO_PCM_LOW_LATENCY is based on the Core Audio (WASAPI)
   // API which was introduced in Windows Vista. For lower Windows versions,
   // a callback-driven Wave implementation is used instead. An input buffer
   // size of 10ms works well for both these implementations.
 
   // Use different buffer sizes depending on the current hardware sample rate.
-  if (input_sample_rate == 44100) {
+  if (in_sample_rate == 44100) {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
-    input_buffer_size = 440;
+    in_buffer_size = 440;
   } else {
-    input_buffer_size = (input_sample_rate / 100);
+    in_buffer_size = (in_sample_rate / 100);
   }
 
   // Render side: AUDIO_PCM_LOW_LATENCY is based on the Core Audio (WASAPI)
   // API which was introduced in Windows Vista. For lower Windows versions,
   // a callback-driven Wave implementation is used instead. An output buffer
   // size of 10ms works well for WASAPI but 30ms is needed for Wave.
 
   // Use different buffer sizes depending on the current hardware sample rate.
-  if (output_sample_rate == 96000 || output_sample_rate == 48000) {
-    output_buffer_size = (output_sample_rate / 100);
+  if (out_sample_rate == 96000 || out_sample_rate == 48000) {
+    out_buffer_size = (out_sample_rate / 100);
   } else {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
     // TODO(henrika): figure out why we seem to need 20ms here for glitch-
     // free audio.
-    output_buffer_size = 2 * 440;
+    out_buffer_size = 2 * 440;
   }
 
   // Windows XP and lower can't cope with 10 ms output buffer size.
   // It must be extended to 30 ms (60 ms will be used internally by WaveOut).
   if (!media::IsWASAPISupported()) {
-    output_buffer_size = 3 * output_buffer_size;
+    out_buffer_size = 3 * out_buffer_size;
     DLOG(WARNING) << "Extending the output buffer size by a factor of three "
                   << "since Windows XP has been detected.";
   }
 
 // Mac OS X
 #elif defined(OS_MACOSX)
-  output_channels = 1;
+  out_channel_layout = CHANNEL_LAYOUT_MONO;
+
+  DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Mac OS X.";
+  in_format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 
   // Capture side: AUDIO_PCM_LOW_LATENCY on Mac OS X is based on a callback-
   // driven Core Audio implementation. Tests have shown that 10ms is a suitable
   // frame size to use, both for 48kHz and 44.1kHz.
 
   // Use different buffer sizes depending on the current hardware sample rate.
-  if (input_sample_rate == 44100) {
+  if (in_sample_rate == 44100) {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
-    input_buffer_size = 440;
+    in_buffer_size = 440;
   } else {
-    input_buffer_size = (input_sample_rate / 100);
+    in_buffer_size = (in_sample_rate / 100);
   }
 
   // Render side: AUDIO_PCM_LOW_LATENCY on Mac OS X is based on a callback-
   // driven Core Audio implementation. Tests have shown that 10ms is a suitable
   // frame size to use, both for 48kHz and 44.1kHz.
 
   // Use different buffer sizes depending on the current hardware sample rate.
-  if (output_sample_rate == 48000) {
-    output_buffer_size = 480;
+  if (out_sample_rate == 48000) {
+    out_buffer_size = 480;
   } else {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
-    output_buffer_size = 440;
+    out_buffer_size = 440;
   }
 // Linux
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
-  input_channels = 2;
-  output_channels = 1;
+  input_channel_layout = CHANNEL_LAYOUT_STEREO;
+  out_channel_layout = CHANNEL_LAYOUT_MONO;
 
   // Based on tests using the current ALSA implementation in Chrome, we have
   // found that the best combination is 20ms on the input side and 10ms on the
   // output side.
   // TODO(henrika): It might be possible to reduce the input buffer
   // size and reduce the delay even more.
-  input_buffer_size = 2 * 480;
-  output_buffer_size = 480;
+  in_buffer_size = 2 * 480;
+  out_buffer_size = 480;
 #else
   DLOG(ERROR) << "Unsupported platform";
   return -1;
 #endif
 
   // Store utilized parameters to ensure that we can check them
   // after a successful initialization.
-  output_buffer_size_ = output_buffer_size;
-  output_channels_ = output_channels;
-  output_sample_rate_ = static_cast<double>(output_sample_rate);
+  output_audio_parameters_.Reset(
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, out_channel_layout,
+      out_sample_rate, 16, out_buffer_size);
 
-  input_buffer_size_ = input_buffer_size;
-  input_channels_ = input_channels;
-  input_sample_rate_ = input_sample_rate;
+  input_audio_parameters_.Reset(
+      in_format, input_channel_layout, in_sample_rate,
+      16, in_buffer_size);
 
   // Create and configure the audio capturing client.
   audio_input_device_ = new AudioInputDevice(
-      input_buffer_size, input_channels, input_sample_rate, this, this);
+      input_audio_parameters_, this, this);
 
   // Create and configure the audio rendering client.
-  audio_output_device_ = new AudioDevice(
-      output_buffer_size, output_channels, output_sample_rate, this);
+  audio_output_device_ = new AudioDevice(output_audio_parameters_, this);
 
   DCHECK(audio_input_device_);
   DCHECK(audio_output_device_);
 
   // Allocate local audio buffers based on the parameters above.
   // It is assumed that each audio sample contains 16 bits and each
   // audio frame contains one or two audio samples depending on the
   // number of channels.
-  input_buffer_.reset(new int16[input_buffer_size * input_channels]);
-  output_buffer_.reset(new int16[output_buffer_size * output_channels]);
+  input_buffer_.reset(new int16[input_buffer_size() * input_channels()]);
+  output_buffer_.reset(new int16[output_buffer_size() * output_channels()]);
 
   DCHECK(input_buffer_.get());
   DCHECK(output_buffer_.get());
 
   bytes_per_sample_ = sizeof(*input_buffer_.get());
 
   initialized_ = true;
 
   DVLOG(1) << "Capture parameters (size/channels/rate): ("
-           << input_buffer_size_ << "/" << input_channels_ << "/"
-           << input_sample_rate_ << ")";
+           << input_buffer_size() << "/" << input_channels() << "/"
+           << input_sample_rate() << ")";
   DVLOG(1) << "Render parameters (size/channels/rate): ("
-           << output_buffer_size_ << "/" << output_channels_ << "/"
-           << output_sample_rate_ << ")";
+           << output_buffer_size() << "/" << output_channels() << "/"
+           << output_sample_rate() << ")";
   return 0;
 }
 
 void WebRtcAudioDeviceImpl::InitOnRenderThread(int32_t* error,
                                                base::WaitableEvent* event) {
   DCHECK(render_loop_->BelongsToCurrentThread());
   *error = Init();
   event->Signal();
 }
 
@@ skipping 357 matching lines @@
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::MicrophoneBoost(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoPlayoutIsAvailable(bool* available) const {
   DCHECK(initialized_) << "Init() must be called first.";
-  *available = (output_channels_ == 2);
+  *available = (output_channels() == 2);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetStereoPlayout(bool enable) {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::SetStereoPlayout() "
            << "NOT IMPLEMENTED";
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoPlayout(bool* enabled) const {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::StereoPlayout() "
            << "NOT IMPLEMENTED";
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoRecordingIsAvailable(
     bool* available) const {
   DCHECK(initialized_) << "Init() must be called first.";
-  *available = (input_channels_ == 2);
+  *available = (input_channels() == 2);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetStereoRecording(bool enable) {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::SetStereoRecording() "
            << "NOT IMPLEMENTED";
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoRecording(bool* enabled) const {
@@ skipping 70 matching lines @@
 int32_t WebRtcAudioDeviceImpl::SetRecordingSampleRate(
     const uint32_t samples_per_sec) {
   // Sample rate should only be set at construction.
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingSampleRate(
     uint32_t* samples_per_sec) const {
   // Returns the sample rate set at construction.
-  *samples_per_sec = static_cast<uint32_t>(input_sample_rate_);
+  *samples_per_sec = static_cast<uint32_t>(input_sample_rate());
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetPlayoutSampleRate(
     const uint32_t samples_per_sec) {
   // Sample rate should only be set at construction.
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutSampleRate(
     uint32_t* samples_per_sec) const {
   // Returns the sample rate set at construction.
-  *samples_per_sec = static_cast<uint32_t>(output_sample_rate_);
+  *samples_per_sec = static_cast<uint32_t>(output_sample_rate());
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::ResetAudioDevice() {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetLoudspeakerStatus(bool enable) {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }