Used 10ms native buffer size for webrtc audio renderer on Linux and Mac

content/renderer/media/webrtc_audio_renderer.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 "content/renderer/media/webrtc_audio_renderer.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 29 matching lines @@
 const int kValidOutputRates[] = {48000, 44100};
 #elif defined(OS_ANDROID)
 // TODO(leozwang): We want to use native sampling rate on Android to achieve
 // low latency, currently 16000 is used to work around audio problem on some
 // Android devices.
 const int kValidOutputRates[] = {48000, 44100, 16000};
 #else
 const int kValidOutputRates[] = {44100};
 #endif
 
-// TODO(xians): Merge the following code to WebRtcAudioCapturer, or remove.
-enum AudioFramesPerBuffer {
-  k160,
-  k320,
-  k440,
-  k480,
-  k640,
-  k880,
-  k960,
-  k1440,
-  k1920,
-  kUnexpectedAudioBufferSize  // Must always be last!
-};
-
-// Helper method to convert integral values to their respective enum values
-// above, or kUnexpectedAudioBufferSize if no match exists.
-// We map 441 to k440 to avoid changes in the XML part for histograms.
-// It is still possible to map the histogram result to the actual buffer size.
-// See http://crbug.com/243450 for details.
-AudioFramesPerBuffer AsAudioFramesPerBuffer(int frames_per_buffer) {
-  switch (frames_per_buffer) {
-    case 160: return k160;
-    case 320: return k320;
-    case 441: return k440;
-    case 480: return k480;
-    case 640: return k640;
-    case 880: return k880;
-    case 960: return k960;
-    case 1440: return k1440;
-    case 1920: return k1920;
-  }
-  return kUnexpectedAudioBufferSize;
-}
-
-void AddHistogramFramesPerBuffer(int param) {
-  AudioFramesPerBuffer afpb = AsAudioFramesPerBuffer(param);
-  if (afpb != kUnexpectedAudioBufferSize) {
-    UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputFramesPerBuffer",
-                              afpb, kUnexpectedAudioBufferSize);
-  } else {
-    // Report unexpected sample rates using a unique histogram name.
-    UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputFramesPerBufferUnexpected", param);
-  }
-}
-
 // This is a simple wrapper class that's handed out to users of a shared
 // WebRtcAudioRenderer instance.  This class maintains the per-user 'playing'
 // and 'started' states to avoid problems related to incorrect usage which
 // might violate the implementation assumptions inside WebRtcAudioRenderer
 // (see the play reference count).
 class SharedAudioRenderer : public MediaStreamAudioRenderer {
  public:
   // Callback definition for a callback that is called when when Play(), Pause()
   // or SetVolume are called (whenever the internal |playing_state_| changes).
   typedef base::Callback<
@@ skipping 86 matching lines @@
       RenderFrameImpl::FromRoutingID(render_frame_id);
   MediaStreamDispatcher* const dispatcher = frame ?
       frame->GetMediaStreamDispatcher() : NULL;
   if (dispatcher && dispatcher->IsAudioDuckingActive()) {
     return media::AudioParameters::DUCKING;
   }
 
   return media::AudioParameters::NO_EFFECTS;
 }
 
+// Helper method to get platform specific optimal buffer size.
+int GetOptimalBufferSize(int sample_rate, int hardware_buffer_size) {
+  // Use native hardware buffer size as default.
+  int frames_per_buffer = hardware_buffer_size;
+
+  // On Windows, we strive to open up using native parameters to achieve best

[tommi (sloooow) - chröme, 2014/09/03 13:22:11]

this comment is a bit confusing since there's no #if for windows... does this
apply to the previous line or should there be a further explanation here that
could explain why there isn't a specific #if for windows.

[no longer working on chromium, 2014/09/03 14:34:50]

I moved the comment up and explained by we don't have #if case for windows.

+  // possible performance and to ensure that no FIFO is needed on the browser
+  // side to match the client request.
+
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+  // On Linux and MacOS, the low level IO implementations on the browser side
+  // supports all buffer size the clients want. We use the native peer
+  // connection buffer size (10ms) to achieve best possible performance.
+  frames_per_buffer = sample_rate / 100;
+#elif defined(OS_ANDROID)
+  // TODO(henrika): Keep tuning this scheme and espcicially for low-latency
+   // cases. Might not be possible to come up with the perfect solution using

[tommi (sloooow) - chröme, 2014/09/03 13:22:11]

fix indenting here and the next line

[no longer working on chromium, 2014/09/03 14:34:50]

Done.

+    // the render side only.
+  if (frames_per_buffer < 2 * frames_per_10ms) {
+    // Examples of low-latency frame sizes and the resulting |buffer_size|:
+    //  Nexus 7     : 240 audio frames => 2*480 = 960
+    //  Nexus 10    : 256              => 2*441 = 882
+    //  Galaxy Nexus: 144              => 2*441 = 882
+    frames_per_buffer = 2 * frames_per_10ms;
+    DVLOG(1) << "Low-latency output detected on Android";
+  }
+#endif
+
+  DVLOG(1) << "Using sink output buffer size: " << frames_per_buffer;
+  return frames_per_buffer;
+}
+
 }  // namespace
 
 WebRtcAudioRenderer::WebRtcAudioRenderer(
     const scoped_refptr<webrtc::MediaStreamInterface>& media_stream,
     int source_render_view_id,
     int source_render_frame_id,
     int session_id,
     int sample_rate,
     int frames_per_buffer)
     : state_(UNINITIALIZED),
@@ skipping 70 matching lines @@
   // The WebRTC client only supports multiples of 10ms as buffer size where
   // 10ms is preferred for lowest possible delay.
   media::AudioParameters source_params;
   const int frames_per_10ms = (sample_rate / 100);
   DVLOG(1) << "Using WebRTC output buffer size: " << frames_per_10ms;
 
   source_params.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                       sink_params_.channel_layout(), sink_params_.channels(),
                       sample_rate, 16, frames_per_10ms);
 
-  // Update audio parameters for the sink, i.e., the native audio output stream.
-  // We strive to open up using native parameters to achieve best possible
-  // performance and to ensure that no FIFO is needed on the browser side to
-  // match the client request. Any mismatch between the source and the sink is
-  // taken care of in this class instead using a pull FIFO.
-
-  // Use native output size as default.
-  int frames_per_buffer = sink_params_.frames_per_buffer();
-#if defined(OS_ANDROID)
-  // TODO(henrika): Keep tuning this scheme and espcicially for low-latency
-  // cases. Might not be possible to come up with the perfect solution using
-  // the render side only.
-  if (frames_per_buffer < 2 * frames_per_10ms) {
-    // Examples of low-latency frame sizes and the resulting |buffer_size|:
-    //  Nexus 7     : 240 audio frames => 2*480 = 960
-    //  Nexus 10    : 256              => 2*441 = 882
-    //  Galaxy Nexus: 144              => 2*441 = 882
-    frames_per_buffer = 2 * frames_per_10ms;
-    DVLOG(1) << "Low-latency output detected on Android";
-  }
-#endif
-  DVLOG(1) << "Using sink output buffer size: " << frames_per_buffer;
+  const int frames_per_buffer =

[henrika (OOO until Aug 14), 2014/09/03 12:43:58]

DVLOG could be useful here.

[no longer working on chromium, 2014/09/03 12:49:26]

There has already been one DVLOG in the end of GetOptimalBufferSize(), see line
185.

+      GetOptimalBufferSize(sample_rate, sink_params_.frames_per_buffer());
 
   sink_params_.Reset(sink_params_.format(), sink_params_.channel_layout(),
                      sink_params_.channels(), sample_rate, 16,
                      frames_per_buffer);
 
   // Create a FIFO if re-buffering is required to match the source input with
   // the sink request. The source acts as provider here and the sink as
   // consumer.
   fifo_delay_milliseconds_ = 0;
   if (source_params.frames_per_buffer() != sink_params_.frames_per_buffer()) {
@@ skipping 21 matching lines @@
       source_render_view_id_, source_render_frame_id_);
 
   DCHECK_GE(session_id_, 0);
   sink_->InitializeWithSessionId(sink_params_, this, session_id_);
 
   sink_->Start();
 
   // User must call Play() before any audio can be heard.
   state_ = PAUSED;
 
-  UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputFramesPerBuffer",
-                            source_params.frames_per_buffer(),
-                            kUnexpectedAudioBufferSize);
-  AddHistogramFramesPerBuffer(source_params.frames_per_buffer());
-
   return true;
 }
 
 scoped_refptr<MediaStreamAudioRenderer>
 WebRtcAudioRenderer::CreateSharedAudioRendererProxy(
     const scoped_refptr<webrtc::MediaStreamInterface>& media_stream) {
   content::SharedAudioRenderer::OnPlayStateChanged on_play_state_changed =
       base::Bind(&WebRtcAudioRenderer::OnPlayStateChanged, this);
   return new SharedAudioRenderer(this, media_stream, on_play_state_changed);
 }
@@ skipping 234 matching lines @@
       if (RemovePlayingState(source, state))
         EnterPauseState();
     } else if (AddPlayingState(source, state)) {
       EnterPlayState();
     }
     UpdateSourceVolume(source);
   }
 }
 
 }  // namespace content