Make AudioParameters a class instead of a struct

content/renderer/media/audio_device.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/audio_device.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 31 matching lines @@
 AudioDevice::AudioDevice()
     : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
       callback_(NULL),
       volume_(1.0),
       stream_id_(0),
       play_on_start_(true),
       is_started_(false) {
   filter_ = RenderThreadImpl::current()->audio_message_filter();
 }
 
-AudioDevice::AudioDevice(size_t buffer_size,
-                         int channels,
-                         double sample_rate,
+AudioDevice::AudioDevice(const AudioParameters& params,
                          RenderCallback* callback)
     : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
-      callback_(NULL),
+      audio_parameters_(params),
+      callback_(callback),
       volume_(1.0),
       stream_id_(0),
       play_on_start_(true),
       is_started_(false) {
   filter_ = RenderThreadImpl::current()->audio_message_filter();
-  Initialize(buffer_size,
-             channels,
-             sample_rate,
-             AudioParameters::AUDIO_PCM_LOW_LATENCY,
-             callback);
 }
 
-void AudioDevice::Initialize(size_t buffer_size,
-                             int channels,
-                             double sample_rate,
-                             AudioParameters::Format latency_format,
+void AudioDevice::Initialize(const AudioParameters& params,
                              RenderCallback* callback) {
   CHECK_EQ(0, stream_id_) <<
       "AudioDevice::Initialize() must be called before Start()";
 
   CHECK(!callback_);  // Calling Initialize() twice?
 
-  audio_parameters_.format = latency_format;
-  audio_parameters_.channels = channels;
-  audio_parameters_.sample_rate = static_cast<int>(sample_rate);
-  audio_parameters_.bits_per_sample = 16;

[vrk (LEFT CHROMIUM), 2012/03/09 20:59:32]

Notice that bits_per_sample was hardcoded to 16 for all AudioDevices.

-  audio_parameters_.samples_per_packet = buffer_size;
-
+  audio_parameters_ = params;
   callback_ = callback;
 }
 
 AudioDevice::~AudioDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
   CHECK_EQ(0, stream_id_);
 }
 
 void AudioDevice::Start() {
@@ skipping 106 matching lines @@
     callback_->OnRenderError();
   }
 }
 
 void AudioDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   DCHECK_GE(length,
-      audio_parameters_.samples_per_packet * sizeof(int16) *
-      audio_parameters_.channels);
+      audio_parameters_.samples_per_packet() * sizeof(int16) *
+      audio_parameters_.channels());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
 
   // Takes care of the case when Stop() is called before OnStreamCreated().
   if (!stream_id_) {
@@ skipping 51 matching lines @@
   }
 
   // Convert the number of pending bytes in the render buffer
   // into milliseconds.
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
 
   TRACE_EVENT0("audio", "AudioDevice::FireRenderCallback");
 
   // Update the audio-delay measurement then ask client to render audio.
   size_t num_frames = render_callback_->Render(audio_data_,
-      audio_parameters_.samples_per_packet, audio_delay_milliseconds);
+      audio_parameters_.samples_per_packet(), audio_delay_milliseconds);
 
   // Interleave, scale, and clip to int16.
   // TODO(crogers): avoid converting to integer here, and pass the data
   // to the browser process as float, so we don't lose precision for
   // audio hardware which has better than 16bit precision.
   int16* data = reinterpret_cast<int16*>(shared_memory_.memory());
   media::InterleaveFloatToInt16(audio_data_, data,
-      audio_parameters_.samples_per_packet);
+      audio_parameters_.samples_per_packet());
 
   // Let the host know we are done.
   media::SetActualDataSizeInBytes(&shared_memory_, memory_length_,
-      num_frames * audio_parameters_.channels * sizeof(data[0]));
+      num_frames * audio_parameters_.channels() * sizeof(data[0]));
 }