Make AudioParameters a class instead of a struct

media/audio/mac/audio_low_latency_output_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_output_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 38 matching lines @@
       source_(NULL),
       output_unit_(0),
       output_device_id_(kAudioObjectUnknown),
       volume_(1),
       hardware_latency_frames_(0) {
   // We must have a manager.
   DCHECK(manager_);
   // A frame is one sample across all channels. In interleaved audio the per
   // frame fields identify the set of n |channels|. In uncompressed audio, a
   // packet is always one frame.
-  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;
-  format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels) / 8;
+  format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   // Calculate the number of sample frames per callback.
-  number_of_frames_ = params.GetPacketSize() / format_.mBytesPerPacket;
+  number_of_frames_ = params.GetBytesPerBuffer() / format_.mBytesPerPacket;
 }
 
 AUAudioOutputStream::~AUAudioOutputStream() {
 }
 
 bool AUAudioOutputStream::Open() {
   // Obtain the current input device selected by the user.
   UInt32 size = sizeof(output_device_id_);
   AudioObjectPropertyAddress default_output_device_address = {
     kAudioHardwarePropertyDefaultOutputDevice,
@@ skipping 163 matching lines @@
                                         AudioBufferList* io_data) {
   AUAudioOutputStream* audio_output =
       static_cast<AUAudioOutputStream*>(user_data);
   DCHECK(audio_output);
   if (!audio_output)
     return -1;
 
   return audio_output->Render(number_of_frames, io_data, output_time_stamp);
 }
 
-double AUAudioOutputStream::HardwareSampleRate() {
+int AUAudioOutputStream::HardwareSampleRate() {
   // Determine the default output device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_output_device_address = {
       kAudioHardwarePropertyDefaultOutputDevice,
       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);
   OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return 0.0;  // error
 
-  return nominal_sample_rate;
+  return static_cast<int>(nominal_sample_rate);
 }
 
 double AUAudioOutputStream::GetHardwareLatency() {
   if (!output_unit_ || output_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 33 matching lines @@
   // Get the delay between the moment getting the callback and the scheduled
   // time stamp that tells when the data is going to be played out.
   UInt64 output_time_ns = AudioConvertHostTimeToNanos(
       output_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   double delay_frames = static_cast<double>
       (1e-9 * (output_time_ns - now_ns) * format_.mSampleRate);
 
   return (delay_frames + hardware_latency_frames_);
 }