Work on improving PpbAudioConfig:RecommendSampleFrameCount

ppapi/shared_impl/ppb_audio_config_shared.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "ppapi/shared_impl/ppb_audio_config_shared.h"
 
+#include "content/renderer/media/audio_hardware.h"
+
 namespace ppapi {
 
 PPB_AudioConfig_Shared::PPB_AudioConfig_Shared(PP_Instance instance)
     : Resource(instance),
       sample_rate_(PP_AUDIOSAMPLERATE_NONE),
       sample_frame_count_(0) {
 }
 
 PPB_AudioConfig_Shared::PPB_AudioConfig_Shared(
     const HostResource& host_resource)
@@ skipping 22 matching lines @@
     PP_Instance instance,
     PP_AudioSampleRate sample_rate,
     uint32_t sample_frame_count) {
   scoped_refptr<PPB_AudioConfig_Shared> object(new PPB_AudioConfig_Shared(
       HostResource::MakeInstanceOnly(instance)));
   if (!object->Init(sample_rate, sample_frame_count))
     return 0;
   return object->GetReference();
 }
 
+// static
+PP_AudioSampleRate PPB_AudioConfig_Shared::RecommendSampleRate(
+    PP_Instance instance) {
+  uint32_t output_sample_rate(audio_hardware::GetOutputSampleRate());
+  switch(output_sample_rate) {
+    case 44100:
+      return PP_AUDIOSAMPLERATE_44100;
+    case 48000:
+      return PP_AUDIOSAMPLERATE_48000;
+  }
+  // Default to 48kHz if there isn't a match.
+  return PP_AUDIOSAMPLERATE_48000;
+}
+
+// static
+uint32_t PPB_AudioConfig_Shared::RecommendSampleFrameCount(
+    PP_Instance instance,
+    PP_AudioSampleRate sample_rate,
+    uint32_t sample_frame_count) {
+  uint32_t output_sample_frame_count(audio_hardware::GetOutputBufferSize());
+  uint32_t output_sample_rate(audio_hardware::GetOutputSampleRate());
+  if (sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
+    sample_frame_count = PP_AUDIOMINSAMPLEFRAMECOUNT;
+  // If client is using same sample rate as audio hardware, then recommend a
+  // multiple of the audio hardware's sample frame count.
+  if ((output_sample_rate == static_cast<uint32_t>(sample_rate)) &&
+      (output_sample_frame_count > 0)) {
+    // Round up input sample_frame_count to nearest multiple.
+    uint32_t multiple = (sample_frame_count + output_sample_frame_count - 1) /
+        output_sample_frame_count;
+    uint32_t recommendation = output_sample_frame_count * multiple;
+    if (recommendation > PP_AUDIOMAXSAMPLEFRAMECOUNT)
+      recommendation = PP_AUDIOMAXSAMPLEFRAMECOUNT;
+    return recommendation;
+  }
+  // Otherwise, recommend a conservative 30ms buffer based on sample rate.
+  const uint32_t kDefault30msAt44100kHz = 1323;
+  const uint32_t kDefault30msAt48000kHz = 1440;
+  switch (sample_rate) {
+    case PP_AUDIOSAMPLERATE_44100:
+      return kDefault30msAt44100kHz;
+    case PP_AUDIOSAMPLERATE_48000:
+      return kDefault30msAt48000kHz;
+    case PP_AUDIOSAMPLERATE_NONE:
+      return 0;
+  }
+  // Unable to make a recommendation.
+  return 0;
+}
+
 thunk::PPB_AudioConfig_API* PPB_AudioConfig_Shared::AsPPB_AudioConfig_API() {
   return this;
 }
 
 PP_AudioSampleRate PPB_AudioConfig_Shared::GetSampleRate() {
   return sample_rate_;
 }
 
 uint32_t PPB_AudioConfig_Shared::GetSampleFrameCount() {
   return sample_frame_count_;
@@ skipping 12 matching lines @@
   if (sample_frame_count > PP_AUDIOMAXSAMPLEFRAMECOUNT ||
       sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
     return false;
 
   sample_rate_ = sample_rate;
   sample_frame_count_ = sample_frame_count;
   return true;
 }
 
 }  // namespace ppapi