Make AudioParameters a class instead of a struct

media/audio/linux/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 164 matching lines @@
 // Since we expect to only be able to wake up with a resolution of
 // kSleepErrorMilliseconds, double that for our minimum required latency.
 const uint32 AlsaPcmOutputStream::kMinLatencyMicros =
     kSleepErrorMilliseconds * 2 * 1000;
 
 AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
                                          const AudioParameters& params,
                                          AlsaWrapper* wrapper,
                                          AudioManagerLinux* manager)
     : requested_device_name_(device_name),
-      pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample)),
-      channels_(params.channels),
-      sample_rate_(params.sample_rate),
-      bytes_per_sample_(params.bits_per_sample / 8),
-      bytes_per_frame_(channels_ * params.bits_per_sample / 8),
+      pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample())),
+      channels_(params.channels()),
+      samples_per_second_(params.samples_per_second()),
+      bytes_per_sample_(params.bits_per_sample() / 8),
+      bytes_per_frame_(channels_ * params.bits_per_sample() / 8),
       should_downmix_(false),
       packet_size_(params.GetPacketSize()),
       micros_per_packet_(FramesToMicros(
-          params.samples_per_packet, sample_rate_)),
+          params.samples_per_packet(), samples_per_second_)),
       latency_micros_(std::max(AlsaPcmOutputStream::kMinLatencyMicros,
                                micros_per_packet_ * 2)),
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       state_(kCreated),
       volume_(1.0f),
       source_callback_(NULL) {
   DCHECK(IsOnAudioThread());
 
   // Sanity check input values.
-  if ((params.sample_rate > kAlsaMaxSampleRate) || (params.sample_rate <= 0)) {
+  if (params.samples_per_second() > kAlsaMaxSampleRate ||
+      params.samples_per_second() <= 0) {
     LOG(WARNING) << "Unsupported audio frequency.";
     TransitionTo(kInError);
   }
 
-  if (AudioParameters::AUDIO_PCM_LINEAR != params.format &&
-      AudioParameters::AUDIO_PCM_LOW_LATENCY != params.format) {
+  if (AudioParameters::AUDIO_PCM_LINEAR != params.format() &&
+      AudioParameters::AUDIO_PCM_LOW_LATENCY != params.format()) {
     LOG(WARNING) << "Unsupported audio format";
     TransitionTo(kInError);
   }
 
   if (pcm_format_ == SND_PCM_FORMAT_UNKNOWN) {
-    LOG(WARNING) << "Unsupported bits per sample: " << params.bits_per_sample;
+    LOG(WARNING) << "Unsupported bits per sample: " << params.bits_per_sample();
     TransitionTo(kInError);
   }
 }
 
 AlsaPcmOutputStream::~AlsaPcmOutputStream() {
   InternalState current_state = state();
   DCHECK(current_state == kCreated ||
          current_state == kIsClosed ||
          current_state == kInError);
   DCHECK(!playback_handle_);
@@ skipping 16 matching lines @@
   // transition out from under us.
   TransitionTo(kIsOpened);
 
   // Try to open the device.
   if (requested_device_name_ == kAutoSelectDevice) {
     playback_handle_ = AutoSelectDevice(latency_micros_);
     if (playback_handle_)
       DVLOG(1) << "Auto-selected device: " << device_name_;
   } else {
     device_name_ = requested_device_name_;
-    playback_handle_ = alsa_util::OpenPlaybackDevice(wrapper_,
-                                                     device_name_.c_str(),
-                                                     channels_, sample_rate_,
-                                                     pcm_format_,
-                                                     latency_micros_);
+    playback_handle_ = alsa_util::OpenPlaybackDevice(
+        wrapper_, device_name_.c_str(), channels_, samples_per_second_,
+        pcm_format_, latency_micros_);
   }
 
   // Finish initializing the stream if the device was opened successfully.
   if (playback_handle_ == NULL) {
     stop_stream_ = true;
     TransitionTo(kInError);
     return false;
   } else {
     bytes_per_output_frame_ = should_downmix_ ? 2 * bytes_per_sample_ :
         bytes_per_frame_;
@@ skipping 284 matching lines @@
   if (stop_stream_)
     return;
 
   uint32 frames_avail_wanted = alsa_buffer_frames_ / 2;
   uint32 available_frames = GetAvailableFrames();
   uint32 frames_in_buffer = buffer_->forward_bytes() / bytes_per_output_frame_;
 
   // Next write is initially scheduled for the moment when half of a packet
   // has been played out.
   uint32 next_fill_time_ms =
-      FramesToMillis(frames_per_packet_ / 2, sample_rate_);
+      FramesToMillis(frames_per_packet_ / 2, samples_per_second_);
 
   if (frames_in_buffer && (frames_in_buffer <= available_frames)) {
     // There is data in the current buffer, consume them immediately if we have
     // enough space in the soundcard.
     next_fill_time_ms = 0;
   } else {
     // Otherwise schedule the next write for the moment when half of the alsa
     // buffer becomes available.
     if (available_frames < frames_avail_wanted) {
       uint32 frames_until_empty_enough = frames_avail_wanted - available_frames;
       next_fill_time_ms =
-          FramesToMillis(frames_until_empty_enough, sample_rate_);
+          FramesToMillis(frames_until_empty_enough, samples_per_second_);
 
       // Adjust for time resolution.
       if (next_fill_time_ms > kNoDataSleepMilliseconds)
         next_fill_time_ms -= kNoDataSleepMilliseconds;
 
       // Avoid back-to-back writing.
       if (next_fill_time_ms < kMinIntervalBetweenOnMoreDataCallsInMs)
         next_fill_time_ms = kMinIntervalBetweenOnMoreDataCallsInMs;
     } else if (available_frames == alsa_buffer_frames_) {
       // Buffer is empty, invoke next write immediately.
@@ skipping 15 matching lines @@
       // base/metrics/histogram.h.
       manager_->GetMessageLoop()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&AlsaPcmOutputStream::WriteTask,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(next_fill_time_ms));
     }
   }
 }
 
-uint32 AlsaPcmOutputStream::FramesToMicros(uint32 frames, uint32 sample_rate) {
-  return frames * base::Time::kMicrosecondsPerSecond / sample_rate;
+uint32 AlsaPcmOutputStream::FramesToMicros(uint32 frames,
+                                           uint32 samples_per_second) {
+  return frames * base::Time::kMicrosecondsPerSecond / samples_per_second;
 }
 
-uint32 AlsaPcmOutputStream::FramesToMillis(uint32 frames, uint32 sample_rate) {
-  return frames * base::Time::kMillisecondsPerSecond / sample_rate;
+uint32 AlsaPcmOutputStream::FramesToMillis(uint32 frames,
+                                           uint32 samples_per_second) {
+  return frames * base::Time::kMillisecondsPerSecond / samples_per_second;
 }
 
 std::string AlsaPcmOutputStream::FindDeviceForChannels(uint32 channels) {
   // Constants specified by the ALSA API for device hints.
   static const int kGetAllDevices = -1;
   static const char kPcmInterfaceName[] = "pcm";
   static const char kIoHintName[] = "IOID";
   static const char kNameHintName[] = "NAME";
 
   const char* wanted_device = GuessSpecificDeviceName(channels);
@@ skipping 94 matching lines @@
   //      remap do some software conversion to make it work.
   //   3) Fallback to kDefaultDevice.
   //   4) If that fails too, try the "plug:" version of kDefaultDevice.
   //   5) Give up.
   snd_pcm_t* handle = NULL;
   device_name_ = FindDeviceForChannels(channels_);
 
   // Step 1.
   if (!device_name_.empty()) {
     if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
-                                                channels_, sample_rate_,
+                                                channels_, samples_per_second_,
                                                 pcm_format_,
                                                 latency)) != NULL) {
       return handle;
     }
 
     // Step 2.
     device_name_ = kPlugPrefix + device_name_;
     if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
-                                                channels_, sample_rate_,
+                                                channels_, samples_per_second_,
                                                 pcm_format_,
                                                 latency)) != NULL) {
       return handle;
     }
   }
 
   // For the kDefaultDevice device, we can only reliably depend on 2-channel
   // output to have the correct ordering according to Lennart.  For the channel
   // formats that we know how to downmix from (3 channel to 8 channel), setup
   // downmixing.
   //
   // TODO(ajwong): We need a SupportsFolding() function.
   uint32 default_channels = channels_;
   if (default_channels > 2 && default_channels <= 8) {
     should_downmix_ = true;
     default_channels = 2;
   }
 
   // Step 3.
   device_name_ = kDefaultDevice;
-  if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
-                                              default_channels, sample_rate_,
-                                              pcm_format_, latency)) != NULL) {
+  if ((handle = alsa_util::OpenPlaybackDevice(
+      wrapper_, device_name_.c_str(), default_channels, samples_per_second_,
+      pcm_format_, latency)) != NULL) {
     return handle;
   }
 
   // Step 4.
   device_name_ = kPlugPrefix + device_name_;
-  if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
-                                              default_channels, sample_rate_,
-                                              pcm_format_, latency)) != NULL) {
+  if ((handle = alsa_util::OpenPlaybackDevice(
+      wrapper_, device_name_.c_str(), default_channels, samples_per_second_,
+      pcm_format_, latency)) != NULL) {
     return handle;
   }
 
   // Unable to open any device.
   device_name_.clear();
   return NULL;
 }
 
 bool AlsaPcmOutputStream::CanTransitionTo(InternalState to) {
   switch (state_) {
@@ skipping 58 matching lines @@
   if (source_callback_)
     source_callback_->OnError(this, code);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(IsOnAudioThread());
   source_callback_ = callback;
 }