[Chromecast] Implement new volume control API

chromecast/media/cma/backend/alsa/stream_mixer_alsa.h

 // 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.
 
 #ifndef CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_
 #define CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_
 
 #include <alsa/asoundlib.h>
 #include <stdint.h>
 
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
 #include "chromecast/media/cma/backend/alsa/audio_filter_interface.h"
 #include "chromecast/media/cma/backend/alsa/media_pipeline_backend_alsa.h"
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa_input.h"
 #include "chromecast/public/cast_media_shlib.h"
+#include "chromecast/public/volume_control.h"
 
 namespace media {
 class AudioBus;
 }  // namespace media
 
 namespace chromecast {
 namespace media {
 class AlsaWrapper;
 class FilterGroup;
 
@@ skipping 33 matching lines @@
 
     // Returns true if the stream is primary. Primary streams will be given
     // precedence for sample rates and will dictate when data is polled.
     virtual bool primary() const = 0;
 
     // Returns a string describing the content type class.
     // Should be from chromecast/media/base/audio_device_ids.h
     // or media/audio/audio_device_description.h
     virtual std::string device_id() const = 0;
 
+    // Returns the content type for volume control.
+    virtual AudioContentType content_type() const = 0;
+
     // Returns true if PrepareToDelete() has been called.
     virtual bool IsDeleting() const = 0;
 
     // Initializes the InputQueue after the mixer is set up. At this point the
     // input can correctly determine the mixer's output sample rate.
     virtual void Initialize(const MediaPipelineBackendAlsa::RenderingDelay&
                                 mixer_rendering_delay) = 0;
 
     // Sets and gets the FilterGroup the InputQueue matches.
     // This is determined at creation to save time matching the InputQueue
@@ skipping 36 matching lines @@
             mixer_rendering_delay) = 0;
 
     // This will be called when a fatal error occurs in the mixer.
     virtual void SignalError(StreamMixerAlsaInput::MixerError error) = 0;
 
     // Notifies the input that it is being removed by the upper layers, and
     // should do whatever is necessary to become ready to delete from the mixer.
     // Once the input is ready to be removed, it should call the supplied
     // |delete_cb|; this should only happen once per input.
     virtual void PrepareToDelete(const OnReadyToDeleteCb& delete_cb) = 0;
+
+    // Sets the multiplier based on this stream's content type. The resulting
+    // output volume should be the content type volume * the per-stream volume
+    // multiplier.
+    virtual void SetContentTypeVolume(float volume) = 0;
+
+    // Sets whether or not this stream should be muted.
+    virtual void SetMuted(bool muted) = 0;
   };
 
   enum State {
     kStateUninitialized,
     kStateNormalPlayback,
     kStateError,
   };
 
   static StreamMixerAlsa* Get();
   static void MakeSingleThreadedForTest();
@@ skipping 20 matching lines @@
   void SetAlsaWrapperForTest(std::unique_ptr<AlsaWrapper> alsa_wrapper);
   void WriteFramesForTest();  // Can be called on any thread.
   void ClearInputsForTest();  // Removes all inputs.
 
   void AddLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
   void RemoveLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
+  // Sets the volume multiplier for the given content |type|.
+  void SetVolume(AudioContentType type, float level);
+
+  // Sets the mute state for the given content |type|.
+  void SetMuted(AudioContentType type, bool muted);
+
+  // Sets the volume multiplier limit for the given content |type|.
+  void SetOutputLimit(AudioContentType type, float limit);
+
  protected:
   StreamMixerAlsa();
   virtual ~StreamMixerAlsa();
 
  private:
   void ResetTaskRunnerForTest();
   void FinalizeOnMixerThread();
   void FinishFinalize();
 
   // Reads the buffer size, period size, start threshold, and avail min value
@@ skipping 43 matching lines @@
   int output_samples_per_second_;
   snd_pcm_t* pcm_;
   snd_pcm_hw_params_t* pcm_hw_params_;
   snd_pcm_status_t* pcm_status_;
   snd_pcm_format_t pcm_format_;
 
   // User-configurable ALSA parameters. This caches the results, so the code
   // only has to interact with the command line parameters once.
   std::string alsa_device_name_;
   snd_pcm_uframes_t alsa_buffer_size_;
-  bool alsa_period_explicitly_set;
   snd_pcm_uframes_t alsa_period_size_;
   snd_pcm_uframes_t alsa_start_threshold_;
   snd_pcm_uframes_t alsa_avail_min_;
 
   State state_;
 
   std::vector<std::unique_ptr<InputQueue>> inputs_;
   std::vector<std::unique_ptr<InputQueue>> ignored_inputs_;
   MediaPipelineBackendAlsa::RenderingDelay rendering_delay_;
 
   std::unique_ptr<base::Timer> retry_write_frames_timer_;
 
   int check_close_timeout_;
   std::unique_ptr<base::Timer> check_close_timer_;
 
   std::vector<std::unique_ptr<FilterGroup>> filter_groups_;
   std::vector<CastMediaShlib::LoopbackAudioObserver*> loopback_observers_;
 
+  std::map<AudioContentType, float> volume_;

[slan, 2017/03/13 22:09:51]

Why not std::unordered_map?

I think that Chrome actually prefers a vector of pairs over small maps for
speed, but I like the syntax of maps way better.

[kmackay, 2017/03/14 00:21:00]

The comment in
https://cs.chromium.org/chromium/src/base/containers/small_map.h?dr=C&l=27
indicates that std::map should be the default. I don't think it matters for
performance reasons since there are only 3 entries, and the callsites are not
performance-critical. Also, to use unordered_map, I would need to define some
hash function for AudioContentType, which is a bit of a pain.

[slan, 2017/03/14 17:21:28]

Acknowledged.

+  std::map<AudioContentType, float> volume_limit_;
+  std::map<AudioContentType, bool> muted_;
+
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsa);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_