MediaRecorder: support sampling rate adaption in AudioTrackRecorder

content/renderer/media/media_recorder_handler_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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
@@ skipping 23 matching lines @@
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 static const std::string kTestStreamUrl = "stream_url";
 static const std::string kTestVideoTrackId = "video_track_id";
 static const std::string kTestAudioTrackId = "audio_track_id";
 static const int kTestAudioChannels = 2;
 static const int kTestAudioBitsPerSample = 16;
 static const int kTestAudioSampleRate = 48000;
-static const int kTestAudioBufferDurationMS = 60;
+// MediaStream Audio Track always provides audio in chunks of 10 ms.

[miu, 2016/01/29 02:37:15]

This is not a global assumption.  The current Chrome implementation may do this,
but that's not something we want to hard-code everywhere.  It's fine if you want
to use 10 ms chunks for these tests, but please don't write comments or var
names to indicate that it is a global assumption.

FYI, this code change will break that assumption:
https://codereview.chromium.org/1647773002/

...and there's been a long-standing TODO to fix the code that forces WebAudio to
use 10 ms chunks.  Chris Jones, the original author and spec editor for WebAudio
was always asking Chrome Eng to use minimally-sized buffers (on the order of 2
ms or less).

[mcasas, 2016/01/29 20:37:34]

Removed the comment. For these tests is fine to use 10ms.

+static const int kMediaStreamAudioTrackBufferDurationMs = 10;
+// Opus works with 60ms buffers, so 6 MediaStreamAudioTrack Buffers are needed
+// to encode one output buffer.
+static const int kRatioOpusToMediaStreamTrackBuffers = 6;
 
 struct MediaRecorderTestParams {
   const bool has_video;
   const bool has_audio;
   const char* const mime_type;
   const char* const codecs;
   const size_t first_encoded_video_frame_size;
   const size_t second_encoded_video_frame_size;
   const size_t first_encoded_audio_frame_size;
   const size_t second_encoded_audio_frame_size;
 };
 
 // Array of valid combinations of video/audio/codecs and expected collected
 // encoded sizes to use for parameterizing MediaRecorderHandlerTest.
 static const MediaRecorderTestParams kMediaRecorderTestParams[] = {
     {true, false, "video/webm", "vp8", 52, 32, 0, 0},
     {true, false, "video/webm", "vp9", 33, 18, 0, 0},
-    {false, true, "video/webm", "vp8", 0, 0, 990, 706}};
+    {false, true, "video/webm", "vp8", 0, 0, 996, 746}};

[miu, 2016/01/29 02:37:15]

It's a bit brittle to require the tests pass based on the number of output bytes
from the encoder.  For instance, if libvpx is updated with some kind of
improvement that changes the number of bytes, you really don't want these unit
tests to start failing, right?  Instead, I'd suggest just checking for an empty
or non-empty result to confirm "the plumbing" is good.

[mcasas, 2016/01/29 20:37:34]

My opinion is that a potential libvpx roller should 
have to deal (personally or not) with the  
consequences of a roll, including potentially 
the breaking these tests, but I understand this is
a judgement call so I'll follow your advice: removed
the whole parameter set in favour of a single
threshold.

 
 class MediaRecorderHandlerTest : public TestWithParam<MediaRecorderTestParams>,
                                  public blink::WebMediaRecorderHandlerClient {
  public:
   MediaRecorderHandlerTest()
       : media_recorder_handler_(new MediaRecorderHandler()),
         audio_source_(kTestAudioChannels,
                       440 /* freq */,
                       kTestAudioSampleRate) {
     EXPECT_FALSE(media_recorder_handler_->recording_);
@@ skipping 33 matching lines @@
     // Avoid issues with non-parameterized tests by calling this outside of ctr.
     if (GetParam().has_video)
       registry_.AddVideoTrack(kTestVideoTrackId);
     if (GetParam().has_audio)
       registry_.AddAudioTrack(kTestAudioTrackId);
   }
 
   scoped_ptr<media::AudioBus> NextAudioBus() {
     scoped_ptr<media::AudioBus> bus(media::AudioBus::Create(
         kTestAudioChannels,
-        kTestAudioSampleRate * kTestAudioBufferDurationMS / 1000));
+        kTestAudioSampleRate * kMediaStreamAudioTrackBufferDurationMs / 1000));
     audio_source_.OnMoreData(bus.get(), 0, 0);
     return bus;
   }
 
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
   // and Sources in |registry_| into believing they are on the right threads.
   const base::MessageLoopForUI message_loop_;
   const ChildProcess child_process_;
   MockMediaStreamRegistry registry_;
 
@@ skipping 150 matching lines @@
       this, registry_.test_stream(), mime_type, WebString(), 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start());
 
   InSequence s;
   const scoped_ptr<media::AudioBus> audio_bus1 = NextAudioBus();
   const scoped_ptr<media::AudioBus> audio_bus2 = NextAudioBus();
 
   media::AudioParameters params(
       media::AudioParameters::AUDIO_PCM_LINEAR, media::CHANNEL_LAYOUT_STEREO,
       kTestAudioSampleRate, kTestAudioBitsPerSample,
-      kTestAudioSampleRate * kTestAudioBufferDurationMS / 1000);
+      kTestAudioSampleRate * kMediaStreamAudioTrackBufferDurationMs / 1000);
   SetAudioFormatForTesting(params);
 
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     // writeData() is pinged a number of times as the WebM header is written;
     // the last time it is called it has the encoded data.
     const size_t kEncodedDataSize = GetParam().first_encoded_audio_frame_size;
     EXPECT_CALL(*this, writeData(_, Lt(kEncodedDataSize), _)).Times(AtLeast(1));
     EXPECT_CALL(*this, writeData(_, kEncodedDataSize, _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
-    OnAudioBusForTesting(*audio_bus1);
+    for (int i = 0; i < kRatioOpusToMediaStreamTrackBuffers; ++i)
+      OnAudioBusForTesting(*audio_bus1);
     run_loop.Run();
   }
 
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     // The second time around writeData() is called a number of times to write
     // the WebM frame header, and then is pinged with the encoded data.
     const size_t kSecondEncodedDataSize =
         GetParam().second_encoded_audio_frame_size;
     EXPECT_CALL(*this, writeData(_, Lt(kSecondEncodedDataSize), _))
         .Times(AtLeast(1));
     EXPECT_CALL(*this, writeData(_, kSecondEncodedDataSize, _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
-    OnAudioBusForTesting(*audio_bus2);
+    for (int i = 0; i < kRatioOpusToMediaStreamTrackBuffers; ++i)
+      OnAudioBusForTesting(*audio_bus2);
     run_loop.Run();
   }
 
   media_recorder_handler_->stop();
 
   // Expect a last call on destruction, with size 0 and |lastInSlice| true.
   EXPECT_CALL(*this, writeData(nullptr, 0, true)).Times(1);
   media_recorder_handler_.reset();
 }
 
 }  // namespace content