blob: eeee9d4b4949ac657e11af6edc68bc3900016ec4 [file] [log] [blame]
// Copyright 2017 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 "media/audio/audio_debug_recording_helper.h"
#include <limits>
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/scoped_task_environment.h"
#include "base/test/test_message_loop.h"
#include "media/base/audio_bus.h"
#include "media/base/audio_sample_types.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::_;
using testing::Return;
#if defined(OS_WIN)
#define IntToStringType base::IntToString16
#else
#define IntToStringType base::IntToString
#endif
namespace media {
namespace {
const base::FilePath::CharType kBaseFileName[] =
FILE_PATH_LITERAL("debug_recording");
const base::FilePath::CharType kFileNameSuffix[] =
FILE_PATH_LITERAL("output.1");
const base::FilePath::CharType kWavExtension[] = FILE_PATH_LITERAL("wav");
} // namespace
// Mock class for the audio file writer that the helper wraps.
class MockAudioDebugFileWriter : public AudioDebugFileWriter {
public:
explicit MockAudioDebugFileWriter(const AudioParameters& params)
: AudioDebugFileWriter(params), reference_data_(nullptr) {}
~MockAudioDebugFileWriter() override = default;
MOCK_METHOD1(DoStart, void(bool));
void Start(base::File file) { DoStart(file.IsValid()); }
MOCK_METHOD0(Stop, void());
// Functions with move-only types as arguments can't be mocked directly, so
// we pass on to DoWrite(). Also, we can verify the data this way.
MOCK_METHOD1(DoWrite, void(AudioBus*));
void Write(std::unique_ptr<AudioBus> data) override {
CHECK(reference_data_);
EXPECT_EQ(reference_data_->channels(), data->channels());
EXPECT_EQ(reference_data_->frames(), data->frames());
for (int i = 0; i < data->channels(); ++i) {
float* data_ptr = data->channel(i);
float* ref_data_ptr = reference_data_->channel(i);
for (int j = 0; j < data->frames(); ++j, ++data_ptr, ++ref_data_ptr)
EXPECT_EQ(*ref_data_ptr, *data_ptr);
}
DoWrite(data.get());
}
MOCK_METHOD0(WillWrite, bool());
// Set reference data to compare against. Must be called before Write() is
// called.
void SetReferenceData(AudioBus* reference_data) {
EXPECT_EQ(params_.channels(), reference_data->channels());
EXPECT_EQ(params_.frames_per_buffer(), reference_data->frames());
reference_data_ = reference_data;
}
private:
AudioBus* reference_data_;
DISALLOW_COPY_AND_ASSIGN(MockAudioDebugFileWriter);
};
// Sub-class of the helper that overrides the CreateAudioDebugFileWriter
// function to create the above mock instead.
class AudioDebugRecordingHelperUnderTest : public AudioDebugRecordingHelper {
public:
AudioDebugRecordingHelperUnderTest(
const AudioParameters& params,
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
base::OnceClosure on_destruction_closure)
: AudioDebugRecordingHelper(params,
std::move(task_runner),
std::move(on_destruction_closure)) {}
~AudioDebugRecordingHelperUnderTest() override = default;
private:
// Creates the mock writer. After the mock writer is returned, we always
// expect Start() to be called on it by the helper.
std::unique_ptr<AudioDebugFileWriter> CreateAudioDebugFileWriter(
const AudioParameters& params) override {
MockAudioDebugFileWriter* writer = new MockAudioDebugFileWriter(params);
EXPECT_CALL(*writer, DoStart(true));
return base::WrapUnique<AudioDebugFileWriter>(writer);
}
DISALLOW_COPY_AND_ASSIGN(AudioDebugRecordingHelperUnderTest);
};
// The test fixture.
class AudioDebugRecordingHelperTest : public ::testing::Test {
public:
AudioDebugRecordingHelperTest()
: file_name_suffix_(base::FilePath(kFileNameSuffix)) {}
~AudioDebugRecordingHelperTest() override = default;
// Helper function that creates a recording helper.
std::unique_ptr<AudioDebugRecordingHelper> CreateRecordingHelper(
const AudioParameters& params,
base::OnceClosure on_destruction_closure) {
return std::make_unique<AudioDebugRecordingHelperUnderTest>(
params, scoped_task_environment_.GetMainThreadTaskRunner(),
std::move(on_destruction_closure));
}
MOCK_METHOD0(OnAudioDebugRecordingHelperDestruction, void());
// Bound and passed to AudioDebugRecordingHelper::EnableDebugRecording as
// AudioDebugRecordingHelper::CreateWavFileCallback.
void CreateWavFile(const base::FilePath& file_name_suffix,
base::OnceCallback<void(base::File)> reply_callback) {
// Check that AudioDebugRecordingHelper::EnableDebugRecording adds file
// extension to file name suffix.
EXPECT_EQ(file_name_suffix_, file_name_suffix);
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath base_file_path(
temp_dir.GetPath().Append(base::FilePath(kBaseFileName)));
base::FilePath file_path =
base_file_path.AddExtension(file_name_suffix.value())
.AddExtension(kWavExtension);
base::File debug_file(
file_path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
// Run |reply_callback| with a valid file for expected
// MockAudioDebugFileWriter::Start mocked call to happen.
std::move(reply_callback).Run(std::move(debug_file));
// File can be removed right away because MockAudioDebugFileWriter::Start is
// called synchronously.
ASSERT_TRUE(base::DeleteFile(file_path, false));
}
protected:
base::FilePath file_name_suffix_;
// The test task environment.
base::test::ScopedTaskEnvironment scoped_task_environment_;
private:
DISALLOW_COPY_AND_ASSIGN(AudioDebugRecordingHelperTest);
};
// Creates a helper with an on destruction closure, and verifies that it's run.
TEST_F(AudioDebugRecordingHelperTest, TestDestructionClosure) {
const AudioParameters params;
std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
CreateRecordingHelper(
params, base::BindOnce(&AudioDebugRecordingHelperTest::
OnAudioDebugRecordingHelperDestruction,
base::Unretained(this)));
EXPECT_CALL(*this, OnAudioDebugRecordingHelperDestruction());
}
// Verifies that disable can be called without being enabled.
TEST_F(AudioDebugRecordingHelperTest, OnlyDisable) {
const AudioParameters params;
std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
CreateRecordingHelper(params, base::OnceClosure());
recording_helper->DisableDebugRecording();
}
TEST_F(AudioDebugRecordingHelperTest, EnableDisable) {
const AudioParameters params;
std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
CreateRecordingHelper(params, base::OnceClosure());
recording_helper->EnableDebugRecording(
file_name_suffix_,
base::BindOnce(&AudioDebugRecordingHelperTest::CreateWavFile,
base::Unretained(this)));
EXPECT_CALL(*static_cast<MockAudioDebugFileWriter*>(
recording_helper->debug_writer_.get()),
Stop());
recording_helper->DisableDebugRecording();
recording_helper->EnableDebugRecording(
file_name_suffix_,
base::BindOnce(&AudioDebugRecordingHelperTest::CreateWavFile,
base::Unretained(this)));
EXPECT_CALL(*static_cast<MockAudioDebugFileWriter*>(
recording_helper->debug_writer_.get()),
Stop());
recording_helper->DisableDebugRecording();
}
TEST_F(AudioDebugRecordingHelperTest, OnData) {
// Only channel layout and frames per buffer is used in the file writer and
// AudioBus, the other parameters are ignored.
const int number_of_frames = 100;
const AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR,
ChannelLayout::CHANNEL_LAYOUT_STEREO, 0, 0,
number_of_frames);
// Setup some data.
const int number_of_samples = number_of_frames * params.channels();
const float step = std::numeric_limits<int16_t>::max() / number_of_frames;
std::unique_ptr<float[]> source_data(new float[number_of_samples]);
for (float i = 0; i < number_of_samples; ++i)
source_data[i] = i * step;
std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(params);
audio_bus->FromInterleaved<Float32SampleTypeTraits>(source_data.get(),
number_of_frames);
std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
CreateRecordingHelper(params, base::OnceClosure());
// Should not do anything.
recording_helper->OnData(audio_bus.get());
recording_helper->EnableDebugRecording(
file_name_suffix_,
base::BindOnce(&AudioDebugRecordingHelperTest::CreateWavFile,
base::Unretained(this)));
MockAudioDebugFileWriter* mock_audio_file_writer =
static_cast<MockAudioDebugFileWriter*>(
recording_helper->debug_writer_.get());
mock_audio_file_writer->SetReferenceData(audio_bus.get());
EXPECT_CALL(*mock_audio_file_writer, DoWrite(_));
recording_helper->OnData(audio_bus.get());
base::RunLoop().RunUntilIdle();
EXPECT_CALL(*mock_audio_file_writer, Stop());
recording_helper->DisableDebugRecording();
// Make sure we clear the loop before enabling again.
base::RunLoop().RunUntilIdle();
// Enable again, this time with two OnData() calls, one OnData() call without
// running the message loop until after disabling, and one call after
// disabling.
recording_helper->EnableDebugRecording(
file_name_suffix_,
base::BindOnce(&AudioDebugRecordingHelperTest::CreateWavFile,
base::Unretained(this)));
mock_audio_file_writer = static_cast<MockAudioDebugFileWriter*>(
recording_helper->debug_writer_.get());
mock_audio_file_writer->SetReferenceData(audio_bus.get());
EXPECT_CALL(*mock_audio_file_writer, DoWrite(_)).Times(2);
recording_helper->OnData(audio_bus.get());
recording_helper->OnData(audio_bus.get());
base::RunLoop().RunUntilIdle();
// This call should not yield a DoWrite() call on the mock, since the message
// loop isn't run until after disabling. WillWrite() is expected since
// recording is enabled.
recording_helper->OnData(audio_bus.get());
EXPECT_CALL(*mock_audio_file_writer, Stop());
recording_helper->DisableDebugRecording();
// This call should not yield a DoWrite() call on the mock either.
recording_helper->OnData(audio_bus.get());
base::RunLoop().RunUntilIdle();
}
} // namespace media