Make AudioParameters a class instead of a struct

media/audio/win/audio_low_latency_output_win.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
@@ skipping 20 matching lines @@
       num_written_frames_(0),
       source_(NULL) {
   CHECK(com_init_.succeeded());
   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 render 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 (in different units) of audio packets which we expect to
   // get from the audio endpoint device in each render event.
-  packet_size_frames_ = params.GetPacketSize() / format_.nBlockAlign;
-  packet_size_bytes_ = params.GetPacketSize();
-  packet_size_ms_ = (1000.0 * packet_size_frames_) / params.sample_rate;
+  packet_size_frames_ = params.GetBytesPerBuffer() / format_.nBlockAlign;
+  packet_size_bytes_ = params.GetBytesPerBuffer();
+  packet_size_ms_ = (1000.0 * packet_size_frames_) / params.sample_rate();
   DVLOG(1) << "Number of bytes per audio frame  : " << frame_size_;
   DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
   DVLOG(1) << "Number of milliseconds per packet: " << packet_size_ms_;
 
   // 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_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_render_event_.IsValid());
@@ skipping 178 matching lines @@
     return;
   }
   volume_ = volume_float;
 }
 
 void WASAPIAudioOutputStream::GetVolume(double* volume) {
   *volume = static_cast<double>(volume_);
 }
 
 // static
-double WASAPIAudioOutputStream::HardwareSampleRate(ERole device_role) {
+int WASAPIAudioOutputStream::HardwareSampleRate(ERole device_role) {
   // It is assumed that this static method is called from a COM thread, i.e.,
   // CoInitializeEx() is not called here again to avoid STA/MTA conflicts.
   ScopedComPtr<IMMDeviceEnumerator> enumerator;
   HRESULT hr =  CoCreateInstance(__uuidof(MMDeviceEnumerator),
                                  NULL,
                                  CLSCTX_INPROC_SERVER,
                                  __uuidof(IMMDeviceEnumerator),
                                  enumerator.ReceiveVoid());
   if (FAILED(hr)) {
     NOTREACHED() << "error code: " << std::hex << hr;
@@ skipping 22 matching lines @@
     return 0.0;
   }
 
   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
   hr = audio_client->GetMixFormat(&audio_engine_mix_format);
   if (FAILED(hr)) {
     NOTREACHED() << "error code: " << std::hex << hr;
     return 0.0;
   }
 
-  return static_cast<double>(audio_engine_mix_format->nSamplesPerSec);
+  return static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
 }
 
 void WASAPIAudioOutputStream::Run() {
   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 
   // Increase the thread priority.
   render_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   // Enable MMCSS to ensure that this thread receives prioritized access to
   // CPU resources.
@@ skipping 489 matching lines @@
 
   // All released interfaces (IAudioRenderClient, IAudioClient, IMMDevice)
   // are now re-initiated and it is now possible to re-start audio rendering.
 
   // Start rendering again using the new default audio endpoint.
   hr = audio_client_->Start();
 
   restart_rendering_mode_ = false;
   return SUCCEEDED(hr);
 }