Make AudioParameters a class instead of a struct

media/audio/win/audio_low_latency_input_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_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "media/audio/audio_util.h"
@@ skipping 14 matching lines @@
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
       sink_(NULL) {
   DCHECK(manager_);
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the Avrt.dll";
 
   // Set up the desired capture format specified by the client.
-  format_.nSamplesPerSec = params.sample_rate;
+  format_.nSamplesPerSec = params.sample_rate();
   format_.wFormatTag = WAVE_FORMAT_PCM;
-  format_.wBitsPerSample = params.bits_per_sample;
-  format_.nChannels = params.channels;
+  format_.wBitsPerSample = params.bits_per_sample();
+  format_.nChannels = params.channels();
   format_.nBlockAlign = (format_.wBitsPerSample / 8) * format_.nChannels;
   format_.nAvgBytesPerSec = format_.nSamplesPerSec * format_.nBlockAlign;
   format_.cbSize = 0;
 
   // Size in bytes of each audio frame.
   frame_size_ = format_.nBlockAlign;
   // Store size of audio packets which we expect to get from the audio
   // endpoint device in each capture event.
-  packet_size_frames_ = params.GetPacketSize() / format_.nBlockAlign;
-  packet_size_bytes_ = params.GetPacketSize();
+  packet_size_frames_ = params.GetBytesPerBuffer() / format_.nBlockAlign;
+  packet_size_bytes_ = params.GetBytesPerBuffer();
   DVLOG(1) << "Number of bytes per audio frame  : " << frame_size_;
   DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
 
   // All events are auto-reset events and non-signaled initially.
 
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_ready_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_ready_event_.IsValid());
 
   // Create the event which will be set in Stop() when capturing shall stop.
   stop_capture_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(stop_capture_event_.IsValid());
 
-  ms_to_frame_count_ = static_cast<double>(params.sample_rate) / 1000.0;
+  ms_to_frame_count_ = static_cast<double>(params.sample_rate()) / 1000.0;
 
   LARGE_INTEGER performance_frequency;
   if (QueryPerformanceFrequency(&performance_frequency)) {
     perf_count_to_100ns_units_ =
         (10000000.0 / static_cast<double>(performance_frequency.QuadPart));
   } else {
     LOG(ERROR) <<  "High-resolution performance counters are not supported.";
     perf_count_to_100ns_units_ = 0.0;
   }
 }
@@ skipping 140 matching lines @@
 
   // Retrieve the current volume level. The value is in the range 0.0 to 1.0.
   float level = 0.0f;
   HRESULT hr = simple_audio_volume_->GetMasterVolume(&level);
   DLOG_IF(WARNING, FAILED(hr)) << "Failed to get input master volume.";
 
   return static_cast<double>(level);
 }
 
 // static
-double WASAPIAudioInputStream::HardwareSampleRate(
+int WASAPIAudioInputStream::HardwareSampleRate(
     const std::string& device_id) {
   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
   HRESULT hr = GetMixFormat(device_id, &audio_engine_mix_format);
   if (FAILED(hr))
-    return 0.0;
+    return 0;
 
-  return static_cast<double>(audio_engine_mix_format->nSamplesPerSec);
+  return static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
 }
 
 // static
 uint32 WASAPIAudioInputStream::HardwareChannelCount(
     const std::string& device_id) {
   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
   HRESULT hr = GetMixFormat(device_id, &audio_engine_mix_format);
   if (FAILED(hr))
     return 0;
 
@@ skipping 376 matching lines @@
                                  audio_capture_client_.ReceiveVoid());
   if (FAILED(hr))
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }