MediaRecorder: support sampling rate adaption in AudioTrackRecorder

content/renderer/media/audio_track_recorder_unittest.cc

Index: content/renderer/media/audio_track_recorder_unittest.cc
diff --git a/content/renderer/media/audio_track_recorder_unittest.cc b/content/renderer/media/audio_track_recorder_unittest.cc
index eac49563fc41629c9ff2d8e268bf2a11203a7276..9de578908a813b584d4bed3c12c95975687df9e0 100644
--- a/content/renderer/media/audio_track_recorder_unittest.cc
+++ b/content/renderer/media/audio_track_recorder_unittest.cc
@@ -38,8 +38,10 @@ const int kDefaultBitsPerSample = 16;
 const int kDefaultSampleRate = 48000;
 // The |frames_per_buffer| field of AudioParameters is not used by ATR.
 const int kIgnoreFramesPerBuffer = 1;
-const int kOpusMaxBufferDurationMS = 120;
+const int kMediaStreamAudioTrackBufferDurationMs = 10;
 
+const int kFramesPerBuffer =
+    kMediaStreamAudioTrackBufferDurationMs * kDefaultSampleRate / 1000;
 }  // namespace
 
 namespace content {
@@ -62,13 +64,32 @@ const ATRTestParams kATRTestParams[] = {
      kDefaultSampleRate,                            /* sample rate */
      kDefaultBitsPerSample},                        /* bits per sample */
     // Change to mono:
-    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY, media::CHANNEL_LAYOUT_MONO,
-     kDefaultSampleRate, kDefaultBitsPerSample},
+    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+     media::CHANNEL_LAYOUT_MONO,
+     kDefaultSampleRate,
+     kDefaultBitsPerSample},
     // Different sampling rate as well:
-    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY, media::CHANNEL_LAYOUT_MONO,
-     24000, kDefaultBitsPerSample},
     {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
-     media::CHANNEL_LAYOUT_STEREO, 8000, kDefaultBitsPerSample},
+      media::CHANNEL_LAYOUT_MONO,
+     24000,
+     kDefaultBitsPerSample},
+    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+     media::CHANNEL_LAYOUT_STEREO,
+     8000,
+     kDefaultBitsPerSample},
+    // Using a non-default Opus sampling rate (48, 24, 16, 12, or 8 kHz).
+    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+     media::CHANNEL_LAYOUT_MONO,
+     22050,

[miu, 2016/01/22 00:14:53]

Note: Increasing the Opus frame duration (as I mentioned in comments above) will
allow you to correctly support 22050 Hz audio, since that would require 20 ms
frame durations.

[mcasas, 2016/01/22 22:03:53]

Acknowledged.

+     kDefaultBitsPerSample},
+    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+     media::CHANNEL_LAYOUT_STEREO,
+     44100,
+     kDefaultBitsPerSample},
+    {media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+     media::CHANNEL_LAYOUT_STEREO,
+     96000,
+     kDefaultBitsPerSample},
 };
 
 class AudioTrackRecorderTest : public TestWithParam<ATRTestParams> {
@@ -103,9 +124,11 @@ class AudioTrackRecorderTest : public TestWithParam<ATRTestParams> {
   ~AudioTrackRecorderTest() {
     opus_decoder_destroy(opus_decoder_);
     opus_decoder_ = nullptr;
-    audio_track_recorder_.reset();
     blink_track_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
+    audio_track_recorder_.reset();
+    // Let the message loop run to finish destroying the recorder properly.
+    base::RunLoop().RunUntilIdle();
   }
 
   void ResetDecoder(const media::AudioParameters& params) {
@@ -116,31 +139,25 @@ class AudioTrackRecorderTest : public TestWithParam<ATRTestParams> {
 
     int error;
     opus_decoder_ =
-        opus_decoder_create(params.sample_rate(), params.channels(), &error);
+        opus_decoder_create(kDefaultSampleRate, params.channels(), &error);
     EXPECT_TRUE(error == OPUS_OK && opus_decoder_);
 
-    max_frames_per_buffer_ =
-        kOpusMaxBufferDurationMS * params.sample_rate() / 1000;
-    buffer_.reset(new float[max_frames_per_buffer_ * params.channels()]);
+    buffer_.reset(new float[kFramesPerBuffer * params.channels()]);
   }
 
   scoped_ptr<media::AudioBus> GetFirstSourceAudioBus() {
     scoped_ptr<media::AudioBus> bus(media::AudioBus::Create(
-        first_params_.channels(),
-        first_params_.sample_rate() *
-            audio_track_recorder_->GetOpusBufferDuration(
-                first_params_.sample_rate()) /
-            1000));
+        first_params_.channels(), first_params_.sample_rate() *
+                                      kMediaStreamAudioTrackBufferDurationMs /
+                                      1000));
     first_source_.OnMoreData(bus.get(), 0, 0);
     return bus;
   }
   scoped_ptr<media::AudioBus> GetSecondSourceAudioBus() {
     scoped_ptr<media::AudioBus> bus(media::AudioBus::Create(
-        second_params_.channels(),
-        second_params_.sample_rate() *
-            audio_track_recorder_->GetOpusBufferDuration(
-                second_params_.sample_rate()) /
-            1000));
+        second_params_.channels(), second_params_.sample_rate() *
+                                       kMediaStreamAudioTrackBufferDurationMs /
+                                       1000));
     second_source_.OnMoreData(bus.get(), 0, 0);
     return bus;
   }
@@ -154,17 +171,14 @@ class AudioTrackRecorderTest : public TestWithParam<ATRTestParams> {
                       scoped_ptr<std::string> encoded_data,
                       base::TimeTicks timestamp) {
     EXPECT_TRUE(!encoded_data->empty());
-
     // Decode |encoded_data| and check we get the expected number of frames
     // per buffer.
     EXPECT_EQ(
-        params.sample_rate() *
-            audio_track_recorder_->GetOpusBufferDuration(params.sample_rate()) /
-            1000,
+        kDefaultSampleRate * kMediaStreamAudioTrackBufferDurationMs / 1000,
         opus_decode_float(
             opus_decoder_,
             reinterpret_cast<uint8_t*>(string_as_array(encoded_data.get())),
-            encoded_data->size(), buffer_.get(), max_frames_per_buffer_, 0));
+            encoded_data->size(), buffer_.get(), kFramesPerBuffer, 0));
 
     DoOnEncodedAudio(params, *encoded_data, timestamp);
   }
@@ -185,7 +199,6 @@ class AudioTrackRecorderTest : public TestWithParam<ATRTestParams> {
 
   // Decoder for verifying data was properly encoded.
   OpusDecoder* opus_decoder_;
-  int max_frames_per_buffer_;
   scoped_ptr<float[]> buffer_;
 
  private: