Support for AudioContextOptions latencyHint.

content/renderer/renderer_blink_platform_impl.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/renderer_blink_platform_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 68 matching lines @@
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/filters/stream_parser_factory.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "storage/common/database/database_identifier.h"
 #include "storage/common/quota/quota_types.h"
 #include "third_party/WebKit/public/platform/BlameContext.h"
 #include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
+#include "third_party/WebKit/public/platform/WebAudioLatencyHint.h"
 #include "third_party/WebKit/public/platform/WebBlobRegistry.h"
 #include "third_party/WebKit/public/platform/WebDeviceLightListener.h"
 #include "third_party/WebKit/public/platform/WebFileInfo.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamCenter.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamCenterClient.h"
 #include "third_party/WebKit/public/platform/WebPluginListBuilder.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
@@ skipping 35 matching lines @@
 #define WebScrollbarBehaviorImpl blink::WebScrollbarBehavior
 #endif
 
 #if defined(ENABLE_WEBRTC)
 #include "content/renderer/media/rtc_certificate_generator.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #endif
 
 using blink::Platform;
 using blink::WebAudioDevice;
+using blink::WebAudioLatencyHint;
 using blink::WebBlobRegistry;
 using blink::WebCanvasCaptureHandler;
 using blink::WebDatabaseObserver;
 using blink::WebFileInfo;
 using blink::WebFileSystem;
 using blink::WebGamepad;
 using blink::WebGamepads;
 using blink::WebIDBFactory;
 using blink::WebImageCaptureFrameGrabber;
 using blink::WebMIDIAccessor;
@@ skipping 25 matching lines @@
 media::AudioParameters GetAudioHardwareParams() {
   blink::WebLocalFrame* const web_frame =
       blink::WebLocalFrame::frameForCurrentContext();
   RenderFrame* const render_frame = RenderFrame::FromWebFrame(web_frame);
   return AudioDeviceFactory::GetOutputDeviceInfo(render_frame->GetRoutingID(),
                                                  0, std::string(),
                                                  web_frame->getSecurityOrigin())
       .output_params();
 }
 
+AudioDeviceFactory::SourceType GetLatencyHintSourceType(
+    WebAudioLatencyHint::Category latency_category) {
+  switch (latency_category) {
+    case WebAudioLatencyHint::CategoryInteractive:
+      return AudioDeviceFactory::kSourceWebAudioInteractive;
+    case WebAudioLatencyHint::CategoryBalanced:
+      return AudioDeviceFactory::kSourceWebAudioBalanced;
+    case WebAudioLatencyHint::CategoryPlayback:
+      return AudioDeviceFactory::kSourceWebAudioPlayback;
+  }
+  NOTREACHED();
+  return AudioDeviceFactory::kSourceWebAudioInteractive;
+}
+
+// Calculate mixer output parameters based on mixer input parameters and

[o1ka, 2016/11/15 22:44:27]

I don't think we need it here. 
And WebAudioDeviceImpl only needs a "switch" part from it, because WebAudio will
output at the sink's sample rate.

[Andrew MacPherson, 2016/11/16 10:58:29]

Sounds good, I will remove this function entirely and move the switch statement
only into the RendererWebAudioDevice.

+// hardware parameters for audio output.
+media::AudioParameters GetLatencyParams(
+    const media::AudioParameters& input_params,
+    const media::AudioParameters& hardware_params,
+    media::AudioLatency::LatencyType latency) {
+  int output_sample_rate = input_params.sample_rate();

[o1ka, 2016/11/15 22:44:27]

(explanation of how this mixer code differs from what WebAudio needs)
WebAudio outputs at sink sample rate, so no input sample rate knowledge is
required

+  bool valid_not_fake_hardware_params =
+      hardware_params.format() != media::AudioParameters::AUDIO_FAKE &&
+      hardware_params.IsValid();
+  int preferred_high_latency_output_buffer_size = 0;
+
+#if !defined(OS_CHROMEOS)
+  // On ChromeOS as well as when a fake device is used, we can rely on the
+  // playback device to handle resampling, so don't waste cycles on it here.
+  // On other systems if hardware parameters are valid and the device is not
+  // fake, resample to hardware sample rate. Otherwise, pass the input one and
+  // let the browser side handle automatic fallback.

[o1ka, 2016/11/15 22:44:27]

(explanation of how this mixer code differs from what WebAudio needs)
This is relevant to mixing logic only

+  if (valid_not_fake_hardware_params) {
+    output_sample_rate = hardware_params.sample_rate();
+    preferred_high_latency_output_buffer_size =
+        hardware_params.frames_per_buffer();
+  }
+#endif
+
+  int output_buffer_size = 0;
+
+  // Adjust output buffer size according to the latency requirement.
+  switch (latency) {
+    case media::AudioLatency::LATENCY_INTERACTIVE:
+      output_buffer_size = media::AudioLatency::GetInteractiveBufferSize(
+          hardware_params.frames_per_buffer());
+      break;
+    case media::AudioLatency::LATENCY_RTC:
+      output_buffer_size = media::AudioLatency::GetRtcBufferSize(
+          output_sample_rate, valid_not_fake_hardware_params
+                                  ? hardware_params.frames_per_buffer()
+                                  : 0);
+      break;
+    case media::AudioLatency::LATENCY_PLAYBACK:
+      output_buffer_size = media::AudioLatency::GetHighLatencyBufferSize(
+          output_sample_rate, preferred_high_latency_output_buffer_size);
+      break;
+    case media::AudioLatency::LATENCY_EXACT_MS:
+    // TODO(olka): add support when WebAudio requires it.
+    default:
+      NOTREACHED();
+  }
+
+  DCHECK_NE(output_buffer_size, 0);
+
+  // Force to 16-bit output for now since we know that works everywhere;
+  // ChromeOS does not support other bit depths.
+  media::AudioParameters params(input_params.format(),
+                                input_params.channel_layout(),
+                                output_sample_rate, 16, output_buffer_size);
+
+  // Specify the latency info to be passed to the browser side.
+  params.set_latency_tag(latency);
+  return params;
+}
+
 }  // namespace
 
 //------------------------------------------------------------------------------
 
 class RendererBlinkPlatformImpl::FileUtilities : public WebFileUtilitiesImpl {
  public:
   explicit FileUtilities(ThreadSafeSender* sender)
       : thread_safe_sender_(sender) {}
   bool getFileInfo(const WebString& path, WebFileInfo& result) override;
 
@@ skipping 445 matching lines @@
 
 unsigned RendererBlinkPlatformImpl::audioHardwareOutputChannels() {
   return GetAudioHardwareParams().channels();
 }
 
 WebDatabaseObserver* RendererBlinkPlatformImpl::databaseObserver() {
   return web_database_observer_impl_.get();
 }
 
 WebAudioDevice* RendererBlinkPlatformImpl::createAudioDevice(
-    size_t buffer_size,
     unsigned input_channels,
     unsigned channels,
-    double sample_rate,
+    const blink::WebAudioLatencyHint& latency_hint,
     WebAudioDevice::RenderCallback* callback,
     const blink::WebString& input_device_id,
     const blink::WebSecurityOrigin& security_origin) {
-  // Use a mock for testing.
-  blink::WebAudioDevice* mock_device =
-      GetContentClient()->renderer()->OverrideCreateAudioDevice(sample_rate);
-  if (mock_device)
-    return mock_device;
-
   // The |channels| does not exactly identify the channel layout of the
   // device. The switch statement below assigns a best guess to the channel
   // layout based on number of channels.
   media::ChannelLayout layout = media::CHANNEL_LAYOUT_UNSUPPORTED;
   switch (channels) {
     case 1:
       layout = media::CHANNEL_LAYOUT_MONO;
       break;
     case 2:
       layout = media::CHANNEL_LAYOUT_STEREO;
@@ skipping 25 matching lines @@
   int session_id = 0;
   if (input_device_id.isNull() ||
       !base::StringToInt(base::UTF16ToUTF8(
           base::StringPiece16(input_device_id)), &session_id)) {
     if (input_channels > 0)
       DLOG(WARNING) << "createAudioDevice(): request for audio input ignored";
 
     input_channels = 0;
   }
 
+  media::AudioParameters input_params(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY, layout,
+      static_cast<int>(GetAudioHardwareParams().sample_rate()), 16,
+      GetAudioHardwareParams().frames_per_buffer());
+
+  AudioDeviceFactory::SourceType source_type(
+      GetLatencyHintSourceType(latency_hint.category()));
+  media::AudioParameters params(
+      GetLatencyParams(input_params, GetAudioHardwareParams(),

[o1ka, 2016/11/15 22:44:27]

I think we just do not need to pass parameters to AudioDevice during creation
(see above). Only channel layout and latency hint. The rest should be calculated
in WebAudioDeviceImpl

[Andrew MacPherson, 2016/11/16 10:58:29]

Will fix in the next commit, thanks!

+                       AudioDeviceFactory::GetSourceLatencyType(source_type)));
+
   // For CHANNEL_LAYOUT_DISCRETE, pass the explicit channel count along with
   // the channel layout when creating an |AudioParameters| object.
-  media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                                layout, static_cast<int>(sample_rate), 16,
-                                buffer_size);
   params.set_channels_for_discrete(channels);
 
+  // Use a mock for testing.
+  blink::WebAudioDevice* mock_device =
+      GetContentClient()->renderer()->OverrideCreateAudioDevice(
+          params.sample_rate(), params.frames_per_buffer());
+  if (mock_device)
+    return mock_device;
+
   return new RendererWebAudioDeviceImpl(
-      params, callback, session_id, static_cast<url::Origin>(security_origin));
+      params, source_type, callback, session_id,
+      static_cast<url::Origin>(security_origin));
 }
 
 bool RendererBlinkPlatformImpl::loadAudioResource(
     blink::WebAudioBus* destination_bus,
     const char* audio_file_data,
     size_t data_size) {
   return DecodeAudioFileData(
       destination_bus, audio_file_data, data_size);
 }
 
@@ skipping 559 matching lines @@
   return &trial_token_validator_;
 }
 
 void RendererBlinkPlatformImpl::workerContextCreated(
     const v8::Local<v8::Context>& worker) {
   GetContentClient()->renderer()->DidInitializeWorkerContextOnWorkerThread(
       worker);
 }
 
 }  // namespace content