MediaRecorder: support sampling rate adaption in AudioTrackRecorder

content/renderer/media/audio_track_recorder_unittest.cc

 // Copyright 2015 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/audio_track_recorder.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 20 matching lines @@
 
 namespace {
 
 // Input audio format.
 const media::AudioParameters::Format kDefaultInputFormat =
     media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
 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 {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 struct ATRTestParams {
   const media::AudioParameters::Format input_format;
   const media::ChannelLayout channel_layout;
   const int sample_rate;
   const int bits_per_sample;
 };
 
 const ATRTestParams kATRTestParams[] = {
     // Equivalent to default settings:
     {media::AudioParameters::AUDIO_PCM_LOW_LATENCY, /* input format */
      media::CHANNEL_LAYOUT_STEREO,                  /* channel layout */
      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> {
  public:
   // Initialize |first_params_| based on test parameters, and |second_params_|
   // to always be the same thing.
   AudioTrackRecorderTest()
       : first_params_(GetParam().input_format,
                       GetParam().channel_layout,
                       GetParam().sample_rate,
@@ skipping 14 matching lines @@
     ResetDecoder(first_params_);
     PrepareBlinkTrack();
     audio_track_recorder_.reset(new AudioTrackRecorder(
         blink_track_, base::Bind(&AudioTrackRecorderTest::OnEncodedAudio,
                                  base::Unretained(this))));
   }
 
   ~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) {
     if (opus_decoder_) {
       opus_decoder_destroy(opus_decoder_);
       opus_decoder_ = nullptr;
     }
 
     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;
   }
 
   MOCK_METHOD3(DoOnEncodedAudio,
                void(const media::AudioParameters& params,
                     std::string encoded_data,
                     base::TimeTicks timestamp));
 
   void OnEncodedAudio(const media::AudioParameters& params,
                       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);
   }
 
   const base::MessageLoop message_loop_;
 
   // ATR and WebMediaStreamTrack for fooling it.
   scoped_ptr<AudioTrackRecorder> audio_track_recorder_;
   blink::WebMediaStreamTrack blink_track_;
 
   // Two different sets of AudioParameters for testing re-init of ATR.
   const media::AudioParameters first_params_;
   const media::AudioParameters second_params_;
 
   // AudioSources for creating AudioBuses.
   media::SineWaveAudioSource first_source_;
   media::SineWaveAudioSource second_source_;
 
   // Decoder for verifying data was properly encoded.
   OpusDecoder* opus_decoder_;
-  int max_frames_per_buffer_;
   scoped_ptr<float[]> buffer_;
 
  private:
   // Prepares a blink track of a given MediaStreamType and attaches the native
   // track, which can be used to capture audio data and pass it to the producer.
   // Adapted from media::WebRTCLocalAudioSourceProviderTest.
   void PrepareBlinkTrack() {
     MockMediaConstraintFactory constraint_factory;
     scoped_refptr<WebRtcAudioCapturer> capturer(
         WebRtcAudioCapturer::CreateCapturer(
@@ skipping 48 matching lines @@
       .WillOnce(RunClosure(quit_closure));
   audio_track_recorder_->OnData(*GetSecondSourceAudioBus(), time3);
 
   run_loop.Run();
   Mock::VerifyAndClearExpectations(this);
 }
 
 INSTANTIATE_TEST_CASE_P(, AudioTrackRecorderTest, ValuesIn(kATRTestParams));
 
 }  // namespace content