Make AudioParameters a class instead of a struct

media/audio/mac/audio_low_latency_input_mac.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/mac/audio_low_latency_input_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
     : manager_(manager),
       sink_(NULL),
       audio_unit_(0),
       input_device_id_(audio_device_id),
       started_(false),
       hardware_latency_frames_(0),
       number_of_channels_in_frame_(0) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
-  format_.mSampleRate = params.sample_rate;
+  format_.mSampleRate = params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
-  format_.mBitsPerChannel = params.bits_per_sample;
-  format_.mChannelsPerFrame = params.channels;
+  format_.mBitsPerChannel = params.bits_per_sample();
+  format_.mChannelsPerFrame = params.channels();
   format_.mFramesPerPacket = 1;  // uncompressed audio
   format_.mBytesPerPacket = (format_.mBitsPerChannel *
-                             params.channels) / 8;
+                             params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   DVLOG(1) << "Desired ouput format: " << format_;
 
   // Calculate the number of sample frames per callback.
-  number_of_frames_ = params.GetPacketSize() / format_.mBytesPerPacket;
+  number_of_frames_ = params.GetBytesPerBuffer() / format_.mBytesPerPacket;
   DVLOG(1) << "Number of frames per callback: " << number_of_frames_;
 
   // Derive size (in bytes) of the buffers that we will render to.
   UInt32 data_byte_size = number_of_frames_ * format_.mBytesPerFrame;
   DVLOG(1) << "Size of data buffer in bytes : " << data_byte_size;
 
   // Allocate AudioBuffers to be used as storage for the received audio.
   // The AudioBufferList structure works as a placeholder for the
   // AudioBuffer structure, which holds a pointer to the actual data buffer.
   audio_data_buffer_.reset(new uint8[data_byte_size]);
   audio_buffer_list_.mNumberBuffers = 1;
 
   AudioBuffer* audio_buffer = audio_buffer_list_.mBuffers;
-  audio_buffer->mNumberChannels = params.channels;
+  audio_buffer->mNumberChannels = params.channels();
   audio_buffer->mDataByteSize = data_byte_size;
   audio_buffer->mData = audio_data_buffer_.get();
 }
 
 AUAudioInputStream::~AUAudioInputStream() {}
 
 // Obtain and open the AUHAL AudioOutputUnit for recording.
 bool AUAudioInputStream::Open() {
   // Verify that we are not already opened.
   if (audio_unit_)
@@ skipping 354 matching lines @@
       ((capture_latency_frames + 0.5) * format_.mBytesPerFrame);
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
   sink_->OnData(this, audio_data, buffer.mDataByteSize, capture_delay_bytes);
 
   return noErr;
 }
 
-double AUAudioInputStream::HardwareSampleRate() {
+int AUAudioInputStream::HardwareSampleRate() {
   // Determine the default input device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_input_device_address = {
     kAudioHardwarePropertyDefaultInputDevice,
     kAudioObjectPropertyScopeGlobal,
     kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
@@ skipping 17 matching lines @@
   result = AudioObjectGetPropertyData(device_id,
                                       &nominal_sample_rate_address,
                                       0,
                                       0,
                                       &info_size,
                                       &nominal_sample_rate);
   DCHECK_EQ(result, 0);
   if (result)
     return 0.0;
 
-  return nominal_sample_rate;
+  return static_cast<int>(nominal_sample_rate);
 }
 
 double AUAudioInputStream::GetHardwareLatency() {
   if (!audio_unit_ || input_device_id_ == kAudioObjectUnknown) {
     DLOG(WARNING) << "Audio unit object is NULL or device ID is unknown";
     return 0.0;
   }
 
   // Get audio unit latency.
   Float64 audio_unit_latency_sec = 0.0;
@@ skipping 77 matching lines @@
   AudioObjectPropertyAddress property_address = {
     kAudioDevicePropertyVolumeScalar,
     kAudioDevicePropertyScopeInput,
     static_cast<UInt32>(channel)
   };
   OSStatus result = AudioObjectIsPropertySettable(input_device_id_,
                                                   &property_address,
                                                   &is_settable);
   return (result == noErr) ? is_settable : false;
 }