Mixing audio with different latency requirements

content/renderer/media/audio_renderer_mixer_manager.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "media/audio/audio_device_description.h"
+#include "media/base/audio_latency.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/audio_renderer_mixer_pool.h"
 #include "media/base/output_device_info.h"
 #include "url/origin.h"
 
 namespace media {
 class AudioRendererMixer;
 class AudioRendererMixerInput;
 class AudioRendererSink;
 }
@@ skipping 28 matching lines @@
   // |source_render_frame_id| refers to the RenderFrame containing the entity
   // rendering the audio.  Caller must ensure AudioRendererMixerManager outlives
   // the returned input. |device_id|, |session_id| and |security_origin|
   // identify the output device to use. If |device_id| is empty and |session_id|
   // is nonzero, output device associated with the opened input device
   // designated by |session_id| is used. Otherwise, |session_id| is ignored.
   media::AudioRendererMixerInput* CreateInput(
       int source_render_frame_id,
       int session_id,
       const std::string& device_id,
-      const url::Origin& security_origin);
+      const url::Origin& security_origin,
+      media::AudioLatency::LatencyType latency);
 
   // AudioRendererMixerPool implementation.
 
   media::AudioRendererMixer* GetMixer(
       int source_render_frame_id,
-      const media::AudioParameters& params,
+      const media::AudioParameters& input_params,
+      media::AudioLatency::LatencyType latency,
       const std::string& device_id,
       const url::Origin& security_origin,
       media::OutputDeviceStatus* device_status) final;
 
-  void ReturnMixer(int source_render_frame_id,
-                   const media::AudioParameters& params,
-                   const std::string& device_id,
-                   const url::Origin& security_origin) final;
+  void ReturnMixer(const media::AudioRendererMixer* mixer) final;
 
   media::OutputDeviceInfo GetOutputDeviceInfo(
       int source_render_frame_id,
       int session_id,
       const std::string& device_id,
       const url::Origin& security_origin) final;
 
  protected:
   explicit AudioRendererMixerManager(
       std::unique_ptr<AudioRendererSinkCache> sink_cache);
 
  private:
   friend class AudioRendererMixerManagerTest;
 
   // Define a key so that only those AudioRendererMixerInputs from the same
   // RenderView, AudioParameters and output device can be mixed together.
   struct MixerKey {
     MixerKey(int source_render_frame_id,
              const media::AudioParameters& params,
+             media::AudioLatency::LatencyType latency,
              const std::string& device_id,
              const url::Origin& security_origin);
     MixerKey(const MixerKey& other);
     int source_render_frame_id;
     media::AudioParameters params;
+    media::AudioLatency::LatencyType latency;
     std::string device_id;
     url::Origin security_origin;
   };
 
   // Custom compare operator for the AudioRendererMixerMap.  Allows reuse of
   // mixers where only irrelevant keys mismatch; e.g., effects, bits per sample.
   struct MixerKeyCompare {
     bool operator()(const MixerKey& a, const MixerKey& b) const {
       if (a.source_render_frame_id != b.source_render_frame_id)
         return a.source_render_frame_id < b.source_render_frame_id;
       if (a.params.channels() != b.params.channels())
         return a.params.channels() < b.params.channels();
 
       // Ignore effects(), bits_per_sample(), format(), and frames_per_buffer(),
       // these parameters do not affect mixer reuse.  All AudioRendererMixer
       // units disable FIFO, so frames_per_buffer() can be safely ignored.
       if (a.params.channel_layout() != b.params.channel_layout())
         return a.params.channel_layout() < b.params.channel_layout();
 
       if (media::AudioDeviceDescription::IsDefaultDevice(a.device_id) &&
           media::AudioDeviceDescription::IsDefaultDevice(b.device_id)) {
         // Both device IDs represent the same default device => do not compare
         // them; the default device is always authorized => ignoring security
         // origin.
-        return false;
+        return CompareLatency(a, b);

[chcunningham, 2016/06/22 02:13:56]

Can you CompareLatency just once above this if and then keep the logic here and
below the same? Maybe I'm missing something subtle

[o1ka, 2016/06/23 16:36:15]

It's me who's missed something :)
Done.

       }
 
       if (a.device_id != b.device_id)
         return a.device_id < b.device_id;
 
+      if (a.security_origin == b.security_origin)
+        return CompareLatency(a, b);
+
       return a.security_origin < b.security_origin;
     }
+
+    bool CompareLatency(const MixerKey& a, const MixerKey& b) const {
+      // LATENCY_EXACT_MS can be mixed only with the same latency type and the
+      // same required buffer duration.
+      if ((a.latency == media::AudioLatency::LATENCY_EXACT_MS) &&
+          (b.latency == media::AudioLatency::LATENCY_EXACT_MS))
+        return a.params.GetBufferDuration() < b.params.GetBufferDuration();
+
+      return a.latency < b.latency;
+    }
   };
 
   // Map of MixerKey to <AudioRendererMixer, Count>.  Count allows
   // AudioRendererMixerManager to keep track explicitly (v.s. RefCounted which
   // is implicit) of the number of outstanding AudioRendererMixers.
   struct AudioRendererMixerReference {
     media::AudioRendererMixer* mixer;
     int ref_count;
     // Mixer sink pointer, to remove a sink from cache upon mixer destruction.
     const media::AudioRendererSink* sink_ptr;
   };
 
   using AudioRendererMixerMap =
       std::map<MixerKey, AudioRendererMixerReference, MixerKeyCompare>;
 
   // Active mixers.
   AudioRendererMixerMap mixers_;
   base::Lock mixers_lock_;
 
   // Mixer sink cache.
   const std::unique_ptr<AudioRendererSinkCache> sink_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_