Make AudioParameters a class instead of a struct

media/audio/linux/alsa_input.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/linux/alsa_input.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 11 matching lines @@
 
 const char* AlsaPcmInputStream::kAutoSelectDevice = "";
 
 AlsaPcmInputStream::AlsaPcmInputStream(AudioManagerLinux* audio_manager,
                                        const std::string& device_name,
                                        const AudioParameters& params,
                                        AlsaWrapper* wrapper)
     : audio_manager_(audio_manager),
       device_name_(device_name),
       params_(params),
-      bytes_per_packet_(params.samples_per_packet *
-                        (params.channels * params.bits_per_sample) / 8),
+      bytes_per_buffer_(params.frames_per_buffer() *
+                        (params.channels() * params.bits_per_sample()) / 8),
       wrapper_(wrapper),
-      packet_duration_ms_(
-          (params.samples_per_packet * base::Time::kMillisecondsPerSecond) /
-          params.sample_rate),
+      buffer_duration_ms_(
+          (params.frames_per_buffer() * base::Time::kMillisecondsPerSecond) /
+          params.sample_rate()),
       callback_(NULL),
       device_handle_(NULL),
       mixer_handle_(NULL),
       mixer_element_handle_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       read_callback_behind_schedule_(false) {
 }
 
 AlsaPcmInputStream::~AlsaPcmInputStream() {}
 
 bool AlsaPcmInputStream::Open() {
   if (device_handle_)
     return false;  // Already open.
 
   snd_pcm_format_t pcm_format = alsa_util::BitsToFormat(
-      params_.bits_per_sample);
+      params_.bits_per_sample());
   if (pcm_format == SND_PCM_FORMAT_UNKNOWN) {
     LOG(WARNING) << "Unsupported bits per sample: "
-                 << params_.bits_per_sample;
+                 << params_.bits_per_sample();
     return false;
   }
 
-  uint32 latency_us = packet_duration_ms_ * kNumPacketsInRingBuffer *
+  uint32 latency_us = buffer_duration_ms_ * kNumPacketsInRingBuffer *
       base::Time::kMicrosecondsPerMillisecond;
 
   // Use the same minimum required latency as output.
   latency_us = std::max(latency_us, AlsaPcmOutputStream::kMinLatencyMicros);
 
   if (device_name_ == kAutoSelectDevice) {
     const char* device_names[] = { kDefaultDevice1, kDefaultDevice2 };
     for (size_t i = 0; i < arraysize(device_names); ++i) {
-      device_handle_ = alsa_util::OpenCaptureDevice(wrapper_, device_names[i],
-                                                    params_.channels,
-                                                    params_.sample_rate,
-                                                    pcm_format, latency_us);
+      device_handle_ = alsa_util::OpenCaptureDevice(
+          wrapper_, device_names[i], params_.channels(),
+          params_.sample_rate(), pcm_format, latency_us);
+
       if (device_handle_) {
         device_name_ = device_names[i];
         break;
       }
     }
   } else {
     device_handle_ = alsa_util::OpenCaptureDevice(wrapper_,
                                                   device_name_.c_str(),
-                                                  params_.channels,
-                                                  params_.sample_rate,
+                                                  params_.channels(),
+                                                  params_.sample_rate(),
                                                   pcm_format, latency_us);
   }
 
   if (device_handle_) {
-    audio_packet_.reset(new uint8[bytes_per_packet_]);
+    audio_buffer_.reset(new uint8[bytes_per_buffer_]);
 
     // Open the microphone mixer.
     mixer_handle_ = alsa_util::OpenMixer(wrapper_, device_name_);
     if (mixer_handle_) {
       mixer_element_handle_ = alsa_util::LoadCaptureMixerElement(
           wrapper_, mixer_handle_);
     }
   }
 
   return device_handle_ != NULL;
 }
 
 void AlsaPcmInputStream::Start(AudioInputCallback* callback) {
   DCHECK(!callback_ && callback);
   callback_ = callback;
   int error = wrapper_->PcmPrepare(device_handle_);
   if (error < 0) {
     HandleError("PcmPrepare", error);
   } else {
     error = wrapper_->PcmStart(device_handle_);
     if (error < 0)
       HandleError("PcmStart", error);
   }
 
   if (error < 0) {
     callback_ = NULL;
   } else {
-    // We start reading data half |packet_duration_ms_| later than when the
-    // packet might have got filled, to accommodate some delays in the audio
+    // We start reading data half |buffer_duration_ms_| later than when the
+    // buffer might have got filled, to accommodate some delays in the audio
     // driver. This could also give us a smooth read sequence going forward.
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(
-        packet_duration_ms_ + packet_duration_ms_ / 2);
+        buffer_duration_ms_ + buffer_duration_ms_ / 2);
     next_read_time_ = base::Time::Now() + delay;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         delay);
 
     audio_manager_->IncreaseActiveInputStreamCount();
   }
 }
 
@@ skipping 39 matching lines @@
 
 void AlsaPcmInputStream::ReadAudio() {
   DCHECK(callback_);
 
   snd_pcm_sframes_t frames = wrapper_->PcmAvailUpdate(device_handle_);
   if (frames < 0) {  // Potentially recoverable error?
     LOG(WARNING) << "PcmAvailUpdate(): " << wrapper_->StrError(frames);
     Recover(frames);
   }
 
-  if (frames < params_.samples_per_packet) {
+  if (frames < params_.frames_per_buffer()) {
     // Not enough data yet or error happened. In both cases wait for a very
     // small duration before checking again.
     // Even Though read callback was behind schedule, there is no data, so
     // reset the next_read_time_.
     if (read_callback_behind_schedule_) {
       next_read_time_ = base::Time::Now();
       read_callback_behind_schedule_ = false;
     }
 
     base::TimeDelta next_check_time = base::TimeDelta::FromMilliseconds(
-        packet_duration_ms_ / 2);
+        buffer_duration_ms_ / 2);
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         next_check_time);
     return;
   }
 
-  int num_packets = frames / params_.samples_per_packet;
-  int num_packets_read = num_packets;
-  int bytes_per_frame = params_.channels * params_.bits_per_sample / 8;
+  int num_buffers = frames / params_.frames_per_buffer();
+  int num_buffers_read = num_buffers;
   uint32 hardware_delay_bytes =
-      static_cast<uint32>(GetCurrentDelay() * bytes_per_frame);
-  while (num_packets--) {
-    int frames_read = wrapper_->PcmReadi(device_handle_, audio_packet_.get(),
-                                         params_.samples_per_packet);
-    if (frames_read == params_.samples_per_packet) {
-      callback_->OnData(this, audio_packet_.get(), bytes_per_packet_,
+      static_cast<uint32>(GetCurrentDelay() * params_.GetBytesPerFrame());
+  while (num_buffers--) {
+    int frames_read = wrapper_->PcmReadi(device_handle_, audio_buffer_.get(),
+                                         params_.frames_per_buffer());
+    if (frames_read == params_.frames_per_buffer()) {
+      callback_->OnData(this, audio_buffer_.get(), bytes_per_buffer_,
                         hardware_delay_bytes);
     } else {
       LOG(WARNING) << "PcmReadi returning less than expected frames: "
-                   << frames_read << " vs. " << params_.samples_per_packet
-                   << ". Dropping this packet.";
+                   << frames_read << " vs. " << params_.frames_per_buffer()
+                   << ". Dropping this buffer.";
     }
   }
 
   next_read_time_ += base::TimeDelta::FromMilliseconds(
-      packet_duration_ms_ * num_packets_read);
+      buffer_duration_ms_ * num_buffers_read);
   base::TimeDelta delay = next_read_time_ - base::Time::Now();
   if (delay < base::TimeDelta()) {
     LOG(WARNING) << "Audio read callback behind schedule by "
-                 << (packet_duration_ms_ - delay.InMilliseconds())
+                 << (buffer_duration_ms_ - delay.InMilliseconds())
                  << " (ms).";
     // Read callback is behind schedule. Assuming there is data pending in
     // the soundcard, invoke the read callback immediate in order to catch up.
     read_callback_behind_schedule_ = true;
     delay = base::TimeDelta();
   }
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
@@ skipping 17 matching lines @@
 void AlsaPcmInputStream::Close() {
   if (device_handle_) {
     weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
     int error = alsa_util::CloseDevice(wrapper_, device_handle_);
     if (error < 0)
       HandleError("PcmClose", error);
 
     if (mixer_handle_)
       alsa_util::CloseMixer(wrapper_, mixer_handle_, device_name_);
 
-    audio_packet_.reset();
+    audio_buffer_.reset();
     device_handle_ = NULL;
     mixer_handle_ = NULL;
     mixer_element_handle_ = NULL;
 
     if (callback_)
       callback_->OnClose(this);
   }
 
   audio_manager_->ReleaseInputStream(this);
 }
@@ skipping 51 matching lines @@
     return 0.0;
   }
 
   return static_cast<double>(current_volume);
 }
 
 void AlsaPcmInputStream::HandleError(const char* method, int error) {
   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
   callback_->OnError(this, error);
 }