offloading_video_encoder_unittest.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <memory>
  5. #include <vector>
  6. #include "base/bind.h"
  7. #include "base/callback_helpers.h"
  8. #include "base/memory/raw_ptr.h"
  9. #include "base/run_loop.h"
  10. #include "base/task/sequenced_task_runner.h"
  11. #include "base/task/thread_pool.h"
  12. #include "base/test/bind.h"
  13. #include "base/test/gmock_callback_support.h"
  14. #include "base/test/task_environment.h"
  15. #include "media/base/media_util.h"
  16. #include "media/base/mock_filters.h"
  17. #include "media/base/offloading_video_encoder.h"
  18. #include "media/base/video_types.h"
  19. #include "testing/gtest/include/gtest/gtest.h"
  20. using ::base::test::RunCallback;
  21. using ::base::test::RunOnceCallback;
  22. using ::testing::_;
  23. using ::testing::DoAll;
  24. using ::testing::Invoke;
  25. using ::testing::Return;
  26. namespace media {
  27. class OffloadingVideoEncoderTest : public testing::Test {
  28. protected:
  29. void SetUp() override {
  30. auto mock_video_encoder = std::make_unique<MockVideoEncoder>();
  31. mock_video_encoder_ = mock_video_encoder.get();
  32. work_runner_ = base::ThreadPool::CreateSequencedTaskRunner({});
  33. callback_runner_ = base::SequencedTaskRunnerHandle::Get();
  34. offloading_encoder_ = std::make_unique<OffloadingVideoEncoder>(
  35. std::move(mock_video_encoder), work_runner_, callback_runner_);
  36. EXPECT_CALL(*mock_video_encoder_, Dtor()).WillOnce(Invoke([this]() {
  37. EXPECT_TRUE(work_runner_->RunsTasksInCurrentSequence());
  38. }));
  39. }
  40. void RunLoop() { task_environment_.RunUntilIdle(); }
  41. base::test::TaskEnvironment task_environment_;
  42. scoped_refptr<base::SequencedTaskRunner> work_runner_;
  43. scoped_refptr<base::SequencedTaskRunner> callback_runner_;
  44. raw_ptr<MockVideoEncoder> mock_video_encoder_;
  45. std::unique_ptr<OffloadingVideoEncoder> offloading_encoder_;
  46. };
  47. TEST_F(OffloadingVideoEncoderTest, Initialize) {
  48. bool called_done = false;
  49. bool called_output = false;
  50. VideoEncoder::Options options;
  51. VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
  52. VideoEncoder::OutputCB output_cb = base::BindLambdaForTesting(
  53. [&](VideoEncoderOutput, absl::optional<VideoEncoder::CodecDescription>) {
  54. EXPECT_TRUE(callback_runner_->RunsTasksInCurrentSequence());
  55. called_output = true;
  56. });
  57. VideoEncoder::EncoderStatusCB done_cb =
  58. base::BindLambdaForTesting([&](EncoderStatus s) {
  59. EXPECT_TRUE(callback_runner_->RunsTasksInCurrentSequence());
  60. called_done = true;
  61. });
  62. EXPECT_CALL(*mock_video_encoder_, Initialize(_, _, _, _))
  63. .WillOnce(Invoke([this](VideoCodecProfile profile,
  64. const VideoEncoder::Options& options,
  65. VideoEncoder::OutputCB output_cb,
  66. VideoEncoder::EncoderStatusCB done_cb) {
  67. EXPECT_TRUE(work_runner_->RunsTasksInCurrentSequence());
  68. std::move(done_cb).Run(EncoderStatus::Codes::kOk);
  69. std::move(output_cb).Run(VideoEncoderOutput(), {});
  70. }));
  71. offloading_encoder_->Initialize(profile, options, std::move(output_cb),
  72. std::move(done_cb));
  73. RunLoop();
  74. EXPECT_TRUE(called_done);
  75. EXPECT_TRUE(called_output);
  76. }
  77. TEST_F(OffloadingVideoEncoderTest, Encode) {
  78. bool called_done = false;
  79. VideoEncoder::EncoderStatusCB done_cb =
  80. base::BindLambdaForTesting([&](EncoderStatus s) {
  81. EXPECT_TRUE(callback_runner_->RunsTasksInCurrentSequence());
  82. called_done = true;
  83. });
  84. EXPECT_CALL(*mock_video_encoder_, Encode(_, _, _))
  85. .WillOnce(Invoke([this](scoped_refptr<VideoFrame> frame, bool key_frame,
  86. VideoEncoder::EncoderStatusCB done_cb) {
  87. EXPECT_TRUE(work_runner_->RunsTasksInCurrentSequence());
  88. std::move(done_cb).Run(EncoderStatus::Codes::kOk);
  89. }));
  90. offloading_encoder_->Encode(nullptr, false, std::move(done_cb));
  91. RunLoop();
  92. EXPECT_TRUE(called_done);
  93. }
  94. TEST_F(OffloadingVideoEncoderTest, ChangeOptions) {
  95. bool called_done = false;
  96. VideoEncoder::Options options;
  97. VideoEncoder::EncoderStatusCB done_cb =
  98. base::BindLambdaForTesting([&](EncoderStatus s) {
  99. EXPECT_TRUE(callback_runner_->RunsTasksInCurrentSequence());
  100. called_done = true;
  101. });
  102. VideoEncoder::OutputCB output_cb = base::BindRepeating(
  103. [](VideoEncoderOutput, absl::optional<VideoEncoder::CodecDescription>) {
  104. });
  105. EXPECT_CALL(*mock_video_encoder_, ChangeOptions(_, _, _))
  106. .WillOnce(Invoke([this](const VideoEncoder::Options& options,
  107. VideoEncoder::OutputCB output_cb,
  108. VideoEncoder::EncoderStatusCB done_cb) {
  109. EXPECT_TRUE(work_runner_->RunsTasksInCurrentSequence());
  110. std::move(done_cb).Run(EncoderStatus::Codes::kOk);
  111. }));
  112. offloading_encoder_->ChangeOptions(options, std::move(output_cb),
  113. std::move(done_cb));
  114. RunLoop();
  115. EXPECT_TRUE(called_done);
  116. }
  117. TEST_F(OffloadingVideoEncoderTest, Flush) {
  118. bool called_done = false;
  119. VideoEncoder::EncoderStatusCB done_cb =
  120. base::BindLambdaForTesting([&](EncoderStatus s) {
  121. EXPECT_TRUE(callback_runner_->RunsTasksInCurrentSequence());
  122. called_done = true;
  123. });
  124. EXPECT_CALL(*mock_video_encoder_, Flush(_))
  125. .WillOnce(Invoke([this](VideoEncoder::EncoderStatusCB done_cb) {
  126. EXPECT_TRUE(work_runner_->RunsTasksInCurrentSequence());
  127. std::move(done_cb).Run(EncoderStatus::Codes::kOk);
  128. }));
  129. offloading_encoder_->Flush(std::move(done_cb));
  130. RunLoop();
  131. EXPECT_TRUE(called_done);
  132. }
  133. } // namespace media