Work on improving PpbAudioConfig:RecommendSampleFrameCount

ppapi/native_client/tests/ppapi_example_audio/audio.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 <nacl/nacl_log.h>
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 17 matching lines @@
 
 
 // Most of this example is borrowed from ppapi/examples/audio/audio.cc
 
 // Separate left and right frequency to make sure we didn't swap L & R.
 // Sounds pretty horrible, though...
 const double kDefaultFrequencyLeft = 400.0;
 const double kDefaultFrequencyRight = 1000.0;
 const uint32_t kDefaultDuration = 10000;
 
-// This sample frequency is guaranteed to work.
-const PP_AudioSampleRate kSampleFrequency = PP_AUDIOSAMPLERATE_44100;
-// Buffer size in units of sample frames.
-// 4096 is a conservative size that should avoid underruns on most systems.
-const uint32_t kSampleFrameCount = 4096;
-
 const double kPi = 3.141592653589;
 const double kTwoPi = 2.0 * kPi;
 
 void LogFailure(const char* msg) {
   NaClLog(LOG_ERROR, "\n*** FAILURE **** example: %s", msg);
 }
 
 class MyInstance : public pp::Instance {
  private:
   void ParseArgs(uint32_t argc, const char* argn[], const char* argv[]) {
@@ skipping 137 matching lines @@
   }
 
   void TestSuite() {
     if (basic_tests_)
       BasicTests();
     if (stress_tests_)
       StressTests();
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
+    const int32_t kSampleFrameCount = 2048;
     ParseArgs(argc, argn, argv);
+    obtained_sample_rate_ = pp::AudioConfig::RecommendSampleRate(this);
     obtained_sample_frame_count_ = pp::AudioConfig::RecommendSampleFrameCount(
-        kSampleFrequency, kSampleFrameCount);
-    config_ = new
-       pp::AudioConfig(this, kSampleFrequency, obtained_sample_frame_count_);
+        this, obtained_sample_rate_, kSampleFrameCount);
+    config_ = new pp::AudioConfig(
+        this, obtained_sample_rate_, obtained_sample_frame_count_);
     CHECK(NULL != config_);
     audio_ = new pp::Audio(this, *config_, SineWaveCallback, this);
     CHECK(NULL != audio_);
     // Run through test suite before attempting real playback.
     TestSuite();
     return true;
   }
 
  private:
   static void SineWaveCallback(void* samples, uint32_t num_bytes, void* thiz) {
     MyInstance* instance = reinterpret_cast<MyInstance*>(thiz);
-    const double delta_l = kTwoPi * instance->frequency_l_ / kSampleFrequency;
-    const double delta_r = kTwoPi * instance->frequency_r_ / kSampleFrequency;
+    const double delta_l = kTwoPi * instance->frequency_l_ /
+                           instance->obtained_sample_rate_;
+    const double delta_r = kTwoPi * instance->frequency_r_ /
+                           instance->obtained_sample_rate_;
 
     // Verify num_bytes and obtained_sample_frame_count match up.
     const int kNumChannelsForStereo = 2;
     const int kSizeOfSample = sizeof(int16_t);
     const size_t single_sample = kNumChannelsForStereo * kSizeOfSample;
 
     // CHECK inside callback is only for testing purposes.
     CHECK(instance->obtained_sample_frame_count_ * single_sample == num_bytes);
 
     // Use per channel audio wave value to avoid clicks on buffer boundries.
@@ skipping 41 matching lines @@
 
   double amplitude_l_;
   double amplitude_r_;
 
   bool headless_;
 
   bool basic_tests_;
   bool stress_tests_;
 
   uint32_t duration_msec_;
+  PP_AudioSampleRate obtained_sample_rate_;
   uint32_t obtained_sample_frame_count_;
 
   int callback_count_;
 };
 
 class MyModule : public pp::Module {
  public:
   // Override CreateInstance to create your customized Instance object.
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   NaClLogModuleInit();
   return new MyModule();
 }
 
 }  // namespace pp