[Chromecast] Implement new volume control API

chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc

 // Copyright 2015 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 "chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 41 matching lines @@
 // Number of samples to report as readable when paused. When paused, the mixer
 // will still pull this many frames each time it tries to write frames, but we
 // fill the frames with silence.
 const int kPausedReadSamples = 512;
 const int kDefaultReadSize = ::media::SincResampler::kDefaultRequestSize;
 const int64_t kNoTimestamp = std::numeric_limits<int64_t>::min();
 
 const int kMaxSlewTimeUpMs = 15;
 const int kMaxSlewTimeDownMs = 15;
 
+std::string AudioContentTypeToString(media::AudioContentType type) {
+  switch (type) {
+    case media::AudioContentType::kAlarm:
+      return "alarm";
+    case media::AudioContentType::kCommunication:
+      return "communication";
+    default:
+      return "media";
+  }
+}
+
 }  // namespace
 
 StreamMixerAlsaInputImpl::StreamMixerAlsaInputImpl(
     StreamMixerAlsaInput::Delegate* delegate,
     int input_samples_per_second,
     bool primary,
     const std::string& device_id,
+    AudioContentType content_type,
     StreamMixerAlsa* mixer)
     : delegate_(delegate),
       input_samples_per_second_(input_samples_per_second),
       primary_(primary),
       device_id_(device_id),
+      content_type_(content_type),
       mixer_(mixer),
       filter_group_(nullptr),
       mixer_task_runner_(mixer_->task_runner()),
       caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       resample_ratio_(1.0),
       state_(kStateUninitialized),
+      stream_volume_multiplier_(1.0f),
+      type_volume_multiplier_(1.0f),
+      mute_volume_multiplier_(1.0f),
       slew_volume_(kMaxSlewTimeUpMs, kMaxSlewTimeDownMs),
       queued_frames_(0),
       queued_frames_including_resampler_(0),
       current_buffer_offset_(0),
       max_queued_frames_(kMaxInputQueueUs * input_samples_per_second /
                          base::Time::kMicrosecondsPerSecond),
       fade_frames_remaining_(0),
       fade_out_frames_total_(0),
       zeroed_frames_(0),
       is_underflowing_(false),
       weak_factory_(this) {
-  LOG(INFO) << "Create " << device_id_ << " (" << this << ")";
+  LOG(INFO) << "Create " << device_id_ << " (" << this
+            << "), content type = " << AudioContentTypeToString(content_type_);
   DCHECK(delegate_);
   DCHECK(mixer_);
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 StreamMixerAlsaInputImpl::~StreamMixerAlsaInputImpl() {
   LOG(INFO) << "Destroy " << device_id_ << " (" << this << ")";
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
 }
 
 int StreamMixerAlsaInputImpl::input_samples_per_second() const {
   return input_samples_per_second_;
 }
 
 bool StreamMixerAlsaInputImpl::primary() const {
   return primary_;
 }
 
 std::string StreamMixerAlsaInputImpl::device_id() const {
   return device_id_;
 }
 
+AudioContentType StreamMixerAlsaInputImpl::content_type() const {
+  return content_type_;
+}
+
 bool StreamMixerAlsaInputImpl::IsDeleting() const {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   return (state_ == kStateFinalFade || state_ == kStateDeleted);
 }
 
 void StreamMixerAlsaInputImpl::Initialize(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   DCHECK(!IsDeleting());
   if (mixer_->output_samples_per_second() != input_samples_per_second_) {
@@ skipping 134 matching lines @@
 void StreamMixerAlsaInputImpl::OnSkipped() {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   if (!is_underflowing_) {
     LOG(WARNING) << "Underflow for " << this;
     is_underflowing_ = true;
   }
   if (state_ == kStateNormalPlayback) {
     // Fade in once this input starts providing data again.
     fade_frames_remaining_ = NormalFadeFrames();
   }
+  slew_volume_.Interrupted();
 }
 
 void StreamMixerAlsaInputImpl::AfterWriteFrames(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   double resampler_queued_frames =
       (resampler_ ? resampler_->BufferedFrames() : 0);
 
   bool queued_more_data = false;
   MediaPipelineBackendAlsa::RenderingDelay total_delay;
@@ skipping 243 matching lines @@
 
   if (state_ == kStateFadingOut) {
     // Tell the mixer that some more data might be available (since when fading
     // out, we can drain the queue completely).
     mixer_->OnFramesQueued();
   }
 }
 
 void StreamMixerAlsaInputImpl::SetVolumeMultiplier(float multiplier) {
   RUN_ON_MIXER_THREAD(SetVolumeMultiplier, multiplier);
-  LOG(INFO) << device_id_ << "(" << this << "): stream volume = " << multiplier;
   DCHECK(!IsDeleting());
-  if (multiplier > 1.0f)
-    multiplier = 1.0f;
-  if (multiplier < 0.0f)
-    multiplier = 0.0f;
-  slew_volume_.SetVolume(multiplier);
+  stream_volume_multiplier_ = std::max(0.0f, std::min(multiplier, 1.0f));
+  float effective_volume = stream_volume_multiplier_ * type_volume_multiplier_ *
+                           mute_volume_multiplier_;
+  LOG(INFO) << device_id_ << "(" << this
+            << "): stream volume = " << stream_volume_multiplier_
+            << ", effective multiplier = " << effective_volume;
+  slew_volume_.SetVolume(effective_volume);
+}
+
+void StreamMixerAlsaInputImpl::SetContentTypeVolume(float volume) {
+  DCHECK(mixer_task_runner_->BelongsToCurrentThread());
+  type_volume_multiplier_ = std::max(0.0f, std::min(volume, 1.0f));
+  float effective_volume = stream_volume_multiplier_ * type_volume_multiplier_ *
+                           mute_volume_multiplier_;
+  LOG(INFO) << device_id_ << "(" << this
+            << "): type volume = " << type_volume_multiplier_
+            << ", effective multiplier = " << effective_volume;
+  slew_volume_.SetVolume(effective_volume);
+}
+
+void StreamMixerAlsaInputImpl::SetMuted(bool muted) {
+  DCHECK(mixer_task_runner_->BelongsToCurrentThread());
+  mute_volume_multiplier_ = muted ? 0.0f : 1.0f;
+  float effective_volume = stream_volume_multiplier_ * type_volume_multiplier_ *
+                           mute_volume_multiplier_;
+  LOG(INFO) << device_id_ << "(" << this
+            << "): mute volume = " << mute_volume_multiplier_
+            << ", effective multiplier = " << effective_volume;
+  slew_volume_.SetVolume(effective_volume);
 }
 
 void StreamMixerAlsaInputImpl::VolumeScaleAccumulate(bool repeat_transition,
                                                      const float* src,
                                                      int frames,
                                                      float* dest) {
   slew_volume_.ProcessFMAC(repeat_transition, src, frames, dest);
 }
 
 }  // namespace media
 }  // namespace chromecast