decoder_selector_unittest.cc 40 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150
  1. // Copyright 2018 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 <tuple>
  6. #include "base/bind.h"
  7. #include "base/check.h"
  8. #include "base/memory/scoped_refptr.h"
  9. #include "base/notreached.h"
  10. #include "base/test/gmock_callback_support.h"
  11. #include "base/test/scoped_feature_list.h"
  12. #include "base/test/task_environment.h"
  13. #include "build/build_config.h"
  14. #include "media/base/demuxer_stream.h"
  15. #include "media/base/media_switches.h"
  16. #include "media/base/media_util.h"
  17. #include "media/base/mock_filters.h"
  18. #include "media/base/test_helpers.h"
  19. #include "media/filters/decoder_selector.h"
  20. #include "media/filters/decrypting_demuxer_stream.h"
  21. #include "testing/gmock/include/gmock/gmock.h"
  22. #include "testing/gtest/include/gtest/gtest.h"
  23. #if !BUILDFLAG(IS_ANDROID)
  24. #include "media/filters/decrypting_audio_decoder.h"
  25. #include "media/filters/decrypting_video_decoder.h"
  26. #endif // !BUILDFLAG(IS_ANDROID)
  27. using ::base::test::RunCallback;
  28. using ::base::test::RunOnceCallback;
  29. using ::testing::_;
  30. using ::testing::AnyNumber;
  31. using ::testing::IsNull;
  32. using ::testing::NiceMock;
  33. using ::testing::NotNull;
  34. using ::testing::Return;
  35. using ::testing::StrictMock;
  36. namespace media {
  37. namespace {
  38. enum DecryptorCapability {
  39. kNoDecryptor,
  40. kDecryptOnly,
  41. kDecryptAndDecode,
  42. };
  43. enum DecoderCapability {
  44. kAlwaysFail,
  45. kClearOnly,
  46. kEncryptedOnly,
  47. kAlwaysSucceed,
  48. };
  49. bool DecoderCapabilitySupportsDecryption(DecoderCapability capability) {
  50. switch (capability) {
  51. case kAlwaysFail:
  52. return false;
  53. case kClearOnly:
  54. return false;
  55. case kEncryptedOnly:
  56. return true;
  57. case kAlwaysSucceed:
  58. return true;
  59. }
  60. }
  61. DecoderStatus IsConfigSupported(DecoderCapability capability,
  62. bool is_encrypted) {
  63. switch (capability) {
  64. case kAlwaysFail:
  65. return DecoderStatus::Codes::kFailed;
  66. case kClearOnly:
  67. return is_encrypted ? DecoderStatus::Codes::kUnsupportedEncryptionMode
  68. : DecoderStatus::Codes::kOk;
  69. case kEncryptedOnly:
  70. return is_encrypted ? DecoderStatus::Codes::kOk
  71. : DecoderStatus::Codes::kUnsupportedEncryptionMode;
  72. case kAlwaysSucceed:
  73. return DecoderStatus::Codes::kOk;
  74. }
  75. }
  76. const int kDecoder1 = 0xabc;
  77. const int kDecoder2 = 0xdef;
  78. const int kDecoder3 = 0x123;
  79. const int kDecoder4 = 0x456;
  80. // Specializations for the AUDIO version of the test.
  81. class AudioDecoderSelectorTestParam {
  82. public:
  83. static constexpr DemuxerStream::Type kStreamType = DemuxerStream::AUDIO;
  84. using StreamTraits = DecoderStreamTraits<DemuxerStream::AUDIO>;
  85. using MockDecoder = MockAudioDecoder;
  86. using Output = AudioBuffer;
  87. using DecoderType = AudioDecoderType;
  88. #if !BUILDFLAG(IS_ANDROID)
  89. using DecryptingDecoder = DecryptingAudioDecoder;
  90. #endif // !BUILDFLAG(IS_ANDROID)
  91. // StreamTraits() takes different parameters depending on the type.
  92. static std::unique_ptr<StreamTraits> CreateStreamTraits(MediaLog* media_log) {
  93. return std::make_unique<StreamTraits>(media_log, CHANNEL_LAYOUT_STEREO,
  94. kSampleFormatPlanarF32);
  95. }
  96. static const base::Feature& ForceHardwareDecodersFeature() {
  97. return kForceHardwareAudioDecoders;
  98. }
  99. static media::DecoderPriority MockDecoderPriorityCB(
  100. const media::AudioDecoderConfig& config,
  101. const media::AudioDecoder& decoder) {
  102. const auto above_cutoff =
  103. config.samples_per_second() > TestAudioConfig::NormalSampleRateValue();
  104. return above_cutoff == decoder.IsPlatformDecoder()
  105. ? media::DecoderPriority::kNormal
  106. : media::DecoderPriority::kDeprioritized;
  107. }
  108. static media::DecoderPriority NormalDecoderPriorityCB(
  109. const media::AudioDecoderConfig& /*config*/,
  110. const media::AudioDecoder& /*decoder*/) {
  111. return media::DecoderPriority::kNormal;
  112. }
  113. static media::DecoderPriority SkipDecoderPriorityCB(
  114. const media::AudioDecoderConfig& /*config*/,
  115. const media::AudioDecoder& /*decoder*/) {
  116. return media::DecoderPriority::kSkipped;
  117. }
  118. static void UseNormalClearDecoderConfig(
  119. StrictMock<MockDemuxerStream>& stream) {
  120. stream.set_audio_decoder_config(TestAudioConfig::Normal());
  121. }
  122. static void UseHighQualityClearDecoderConfig(
  123. StrictMock<MockDemuxerStream>& stream) {
  124. stream.set_audio_decoder_config(TestAudioConfig::HighSampleRate());
  125. }
  126. static void UseNormalEncryptedDecoderConfig(
  127. StrictMock<MockDemuxerStream>& stream) {
  128. stream.set_audio_decoder_config(TestAudioConfig::NormalEncrypted());
  129. }
  130. static void UseHighQualityEncryptedDecoderConfig(
  131. StrictMock<MockDemuxerStream>& stream) {
  132. stream.set_audio_decoder_config(TestAudioConfig::HighSampleRateEncrypted());
  133. }
  134. // Decoder::Initialize() takes different parameters depending on the type.
  135. static void ExpectInitialize(MockDecoder* decoder,
  136. DecoderCapability capability) {
  137. EXPECT_CALL(*decoder, Initialize_(_, _, _, _, _))
  138. .WillRepeatedly([capability](const AudioDecoderConfig& config,
  139. CdmContext*, AudioDecoder::InitCB& init_cb,
  140. const AudioDecoder::OutputCB&,
  141. const WaitingCB&) {
  142. std::move(init_cb).Run(
  143. IsConfigSupported(capability, config.is_encrypted()));
  144. });
  145. }
  146. static void ExpectNotInitialize(MockDecoder* decoder) {
  147. EXPECT_CALL(*decoder, Initialize_(_, _, _, _, _)).Times(0);
  148. }
  149. };
  150. // Allocate storage for the member variables.
  151. constexpr DemuxerStream::Type AudioDecoderSelectorTestParam::kStreamType;
  152. // Specializations for the VIDEO version of the test.
  153. class VideoDecoderSelectorTestParam {
  154. public:
  155. static constexpr DemuxerStream::Type kStreamType = DemuxerStream::VIDEO;
  156. using StreamTraits = DecoderStreamTraits<DemuxerStream::VIDEO>;
  157. using MockDecoder = MockVideoDecoder;
  158. using Output = VideoFrame;
  159. using DecoderType = VideoDecoderType;
  160. #if !BUILDFLAG(IS_ANDROID)
  161. using DecryptingDecoder = DecryptingVideoDecoder;
  162. #endif // !BUILDFLAG(IS_ANDROID)
  163. static const base::Feature& ForceHardwareDecodersFeature() {
  164. return kForceHardwareVideoDecoders;
  165. }
  166. static std::unique_ptr<StreamTraits> CreateStreamTraits(MediaLog* media_log) {
  167. return std::make_unique<StreamTraits>(media_log);
  168. }
  169. static media::DecoderPriority MockDecoderPriorityCB(
  170. const media::VideoDecoderConfig& config,
  171. const media::VideoDecoder& decoder) {
  172. auto const above_cutoff = config.visible_rect().height() >
  173. TestVideoConfig::NormalCodedSize().height();
  174. return decoder.IsPlatformDecoder() == above_cutoff
  175. ? media::DecoderPriority::kNormal
  176. : media::DecoderPriority::kDeprioritized;
  177. }
  178. static media::DecoderPriority NormalDecoderPriorityCB(
  179. const media::VideoDecoderConfig& /*config*/,
  180. const media::VideoDecoder& /*decoder*/) {
  181. return media::DecoderPriority::kNormal;
  182. }
  183. static media::DecoderPriority SkipDecoderPriorityCB(
  184. const media::VideoDecoderConfig& /*config*/,
  185. const media::VideoDecoder& /*decoder*/) {
  186. return media::DecoderPriority::kSkipped;
  187. }
  188. static void UseNormalClearDecoderConfig(
  189. StrictMock<MockDemuxerStream>& stream) {
  190. stream.set_video_decoder_config(TestVideoConfig::Normal());
  191. }
  192. static void UseHighQualityClearDecoderConfig(
  193. StrictMock<MockDemuxerStream>& stream) {
  194. stream.set_video_decoder_config(TestVideoConfig::Large());
  195. }
  196. static void UseNormalEncryptedDecoderConfig(
  197. StrictMock<MockDemuxerStream>& stream) {
  198. stream.set_video_decoder_config(TestVideoConfig::NormalEncrypted());
  199. }
  200. static void UseHighQualityEncryptedDecoderConfig(
  201. StrictMock<MockDemuxerStream>& stream) {
  202. stream.set_video_decoder_config(TestVideoConfig::LargeEncrypted());
  203. }
  204. static void ExpectInitialize(MockDecoder* decoder,
  205. DecoderCapability capability) {
  206. EXPECT_CALL(*decoder, Initialize_(_, _, _, _, _, _))
  207. .WillRepeatedly(
  208. [capability](const VideoDecoderConfig& config, bool low_delay,
  209. CdmContext*, VideoDecoder::InitCB& init_cb,
  210. const VideoDecoder::OutputCB&, const WaitingCB&) {
  211. std::move(init_cb).Run(
  212. IsConfigSupported(capability, config.is_encrypted()));
  213. });
  214. }
  215. static void ExpectNotInitialize(MockDecoder* decoder) {
  216. EXPECT_CALL(*decoder, Initialize_(_, _, _, _, _, _)).Times(0);
  217. }
  218. };
  219. // Allocate storate for the member variables.
  220. constexpr DemuxerStream::Type VideoDecoderSelectorTestParam::kStreamType;
  221. } // namespace
  222. // Note: The parameter is called TypeParam in the test cases regardless of what
  223. // we call it here. It's been named the same for convenience.
  224. // Note: The test fixtures inherit from this class. Inside the test cases the
  225. // test fixture class is called TestFixture.
  226. template <typename TypeParam>
  227. class DecoderSelectorTest : public ::testing::Test {
  228. public:
  229. // Convenience aliases.
  230. using Self = DecoderSelectorTest<TypeParam>;
  231. using StreamTraits = typename TypeParam::StreamTraits;
  232. using Decoder = typename StreamTraits::DecoderType;
  233. using MockDecoder = typename TypeParam::MockDecoder;
  234. using Output = typename TypeParam::Output;
  235. using DecoderType = typename TypeParam::DecoderType;
  236. using Selector = DecoderSelector<TypeParam::kStreamType>;
  237. struct MockDecoderArgs {
  238. static MockDecoderArgs Create(int decoder_id,
  239. DecoderCapability capability) {
  240. MockDecoderArgs result;
  241. result.decoder_id = decoder_id;
  242. result.capability = capability;
  243. result.supports_decryption =
  244. DecoderCapabilitySupportsDecryption(capability);
  245. result.is_platform_decoder = false;
  246. result.expect_not_initialized = false;
  247. return result;
  248. }
  249. int decoder_id;
  250. DecoderCapability capability;
  251. bool supports_decryption;
  252. bool is_platform_decoder;
  253. bool expect_not_initialized;
  254. };
  255. DecoderSelectorTest()
  256. : traits_(TypeParam::CreateStreamTraits(&media_log_)),
  257. demuxer_stream_(TypeParam::kStreamType) {}
  258. DecoderSelectorTest(const DecoderSelectorTest&) = delete;
  259. DecoderSelectorTest& operator=(const DecoderSelectorTest&) = delete;
  260. void OnWaiting(WaitingReason reason) { NOTREACHED(); }
  261. void OnOutput(scoped_refptr<Output> output) { NOTREACHED(); }
  262. MOCK_METHOD0_T(NoDecoderSelected, void());
  263. MOCK_METHOD1_T(OnDecoderSelected, void(int));
  264. MOCK_METHOD1_T(OnDecoderSelected, void(DecoderType));
  265. MOCK_METHOD1_T(OnDemuxerStreamSelected,
  266. void(std::unique_ptr<DecryptingDemuxerStream>));
  267. void OnDecoderSelectedThunk(
  268. typename Selector::DecoderOrError decoder,
  269. std::unique_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
  270. // Report only the type or id of the decoder, since that's what the tests
  271. // care about. The decoder will be destructed immediately.
  272. if (decoder.has_value() &&
  273. decoder->GetDecoderType() == DecoderType::kTesting) {
  274. OnDecoderSelected(
  275. static_cast<MockDecoder*>(std::move(decoder).value().get())
  276. ->GetDecoderId());
  277. } else if (decoder.has_value()) {
  278. OnDecoderSelected(decoder->GetDecoderType());
  279. } else {
  280. NoDecoderSelected();
  281. }
  282. if (decrypting_demuxer_stream)
  283. OnDemuxerStreamSelected(std::move(decrypting_demuxer_stream));
  284. }
  285. void AddDecryptingDecoder() {
  286. // Require the DecryptingDecoder to be first, because that's easier to
  287. // implement.
  288. DCHECK(mock_decoders_to_create_.empty());
  289. DCHECK(!use_decrypting_decoder_);
  290. use_decrypting_decoder_ = true;
  291. }
  292. void AddMockDecoder(int decoder_id, DecoderCapability capability) {
  293. auto args = MockDecoderArgs::Create(decoder_id, capability);
  294. AddMockDecoder(std::move(args));
  295. }
  296. void AddMockPlatformDecoder(int decoder_id, DecoderCapability capability) {
  297. auto args = MockDecoderArgs::Create(std::move(decoder_id), capability);
  298. args.is_platform_decoder = true;
  299. AddMockDecoder(std::move(args));
  300. }
  301. void AddMockDecoder(MockDecoderArgs args) {
  302. // Actual decoders are created in CreateDecoders(), which may be called
  303. // multiple times by the DecoderSelector.
  304. mock_decoders_to_create_.push_back(std::move(args));
  305. }
  306. std::vector<std::unique_ptr<Decoder>> CreateDecoders() {
  307. std::vector<std::unique_ptr<Decoder>> decoders;
  308. #if !BUILDFLAG(IS_ANDROID)
  309. if (use_decrypting_decoder_) {
  310. decoders.push_back(
  311. std::make_unique<typename TypeParam::DecryptingDecoder>(
  312. task_environment_.GetMainThreadTaskRunner(), &media_log_));
  313. }
  314. #endif // !BUILDFLAG(IS_ANDROID)
  315. for (const auto& args : mock_decoders_to_create_) {
  316. std::unique_ptr<StrictMock<MockDecoder>> decoder =
  317. std::make_unique<StrictMock<MockDecoder>>(args.is_platform_decoder,
  318. args.supports_decryption,
  319. args.decoder_id);
  320. if (args.expect_not_initialized) {
  321. TypeParam::ExpectNotInitialize(decoder.get());
  322. } else {
  323. TypeParam::ExpectInitialize(decoder.get(), args.capability);
  324. }
  325. decoders.push_back(std::move(decoder));
  326. }
  327. return decoders;
  328. }
  329. void CreateCdmContext(DecryptorCapability capability) {
  330. DCHECK(!decoder_selector_);
  331. cdm_context_ = std::make_unique<StrictMock<MockCdmContext>>();
  332. EXPECT_CALL(*cdm_context_, RegisterEventCB(_)).Times(AnyNumber());
  333. if (capability == kNoDecryptor) {
  334. EXPECT_CALL(*cdm_context_, GetDecryptor())
  335. .WillRepeatedly(Return(nullptr));
  336. return;
  337. }
  338. decryptor_ = std::make_unique<NiceMock<MockDecryptor>>();
  339. EXPECT_CALL(*cdm_context_, GetDecryptor())
  340. .WillRepeatedly(Return(decryptor_.get()));
  341. switch (TypeParam::kStreamType) {
  342. case DemuxerStream::AUDIO:
  343. EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
  344. .WillRepeatedly(
  345. RunOnceCallback<1>(capability == kDecryptAndDecode));
  346. break;
  347. case DemuxerStream::VIDEO:
  348. EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
  349. .WillRepeatedly(
  350. RunOnceCallback<1>(capability == kDecryptAndDecode));
  351. break;
  352. default:
  353. NOTREACHED();
  354. }
  355. }
  356. void CreateDecoderSelector() {
  357. decoder_selector_ = std::make_unique<Selector>(
  358. task_environment_.GetMainThreadTaskRunner(),
  359. base::BindRepeating(&Self::CreateDecoders, base::Unretained(this)),
  360. &media_log_);
  361. decoder_selector_->Initialize(
  362. traits_.get(), &demuxer_stream_, cdm_context_.get(),
  363. base::BindRepeating(&Self::OnWaiting, base::Unretained(this)));
  364. }
  365. void UseClearDecoderConfig() {
  366. TypeParam::UseNormalClearDecoderConfig(demuxer_stream_);
  367. }
  368. void UseHighQualityClearDecoderConfig() {
  369. TypeParam::UseHighQualityClearDecoderConfig(demuxer_stream_);
  370. }
  371. void UseEncryptedDecoderConfig() {
  372. TypeParam::UseNormalEncryptedDecoderConfig(demuxer_stream_);
  373. }
  374. void UseHighQualityEncryptedDecoderConfig() {
  375. TypeParam::UseHighQualityEncryptedDecoderConfig(demuxer_stream_);
  376. }
  377. void SelectNextDecoder() {
  378. if (is_selecting_) {
  379. decoder_selector_->ResumeDecoderSelection(
  380. base::BindOnce(&Self::OnDecoderSelectedThunk, base::Unretained(this)),
  381. base::BindRepeating(&Self::OnOutput, base::Unretained(this)),
  382. DecoderStatus::Codes::kFailed);
  383. } else {
  384. decoder_selector_->BeginDecoderSelection(
  385. base::BindOnce(&Self::OnDecoderSelectedThunk, base::Unretained(this)),
  386. base::BindRepeating(&Self::OnOutput, base::Unretained(this)));
  387. }
  388. is_selecting_ = true;
  389. RunUntilIdle();
  390. }
  391. void FinalizeDecoderSelection() {
  392. decoder_selector_->FinalizeDecoderSelection();
  393. is_selecting_ = false;
  394. }
  395. void RunUntilIdle() { task_environment_.RunUntilIdle(); }
  396. base::test::TaskEnvironment task_environment_;
  397. NullMediaLog media_log_;
  398. std::unique_ptr<StreamTraits> traits_;
  399. StrictMock<MockDemuxerStream> demuxer_stream_;
  400. std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
  401. std::unique_ptr<NiceMock<MockDecryptor>> decryptor_;
  402. std::unique_ptr<Selector> decoder_selector_;
  403. bool use_decrypting_decoder_ = false;
  404. bool is_selecting_ = false;
  405. std::vector<MockDecoderArgs> mock_decoders_to_create_;
  406. };
  407. using VideoDecoderSelectorTest =
  408. DecoderSelectorTest<VideoDecoderSelectorTestParam>;
  409. using DecoderSelectorTestParams =
  410. ::testing::Types<AudioDecoderSelectorTestParam,
  411. VideoDecoderSelectorTestParam>;
  412. TYPED_TEST_SUITE(DecoderSelectorTest, DecoderSelectorTestParams);
  413. // Tests for clear streams. CDM will not be used for clear streams so
  414. // DecryptorCapability doesn't really matter.
  415. TYPED_TEST(DecoderSelectorTest, ClearStream_NoDecoders) {
  416. this->UseClearDecoderConfig();
  417. this->CreateDecoderSelector();
  418. EXPECT_CALL(*this, NoDecoderSelected());
  419. this->SelectNextDecoder();
  420. }
  421. TYPED_TEST(DecoderSelectorTest, ClearStream_NoClearDecoder) {
  422. this->AddDecryptingDecoder();
  423. this->UseClearDecoderConfig();
  424. this->CreateDecoderSelector();
  425. EXPECT_CALL(*this, NoDecoderSelected());
  426. this->SelectNextDecoder();
  427. }
  428. TYPED_TEST(DecoderSelectorTest, ClearStream_OneClearDecoder) {
  429. this->AddMockDecoder(kDecoder1, kClearOnly);
  430. this->UseClearDecoderConfig();
  431. this->CreateDecoderSelector();
  432. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  433. this->SelectNextDecoder();
  434. }
  435. TYPED_TEST(DecoderSelectorTest, ClearStream_InternalFallback) {
  436. this->AddMockDecoder(kDecoder1, kAlwaysFail);
  437. this->AddMockDecoder(kDecoder2, kClearOnly);
  438. this->UseClearDecoderConfig();
  439. this->CreateDecoderSelector();
  440. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  441. this->SelectNextDecoder();
  442. }
  443. TYPED_TEST(DecoderSelectorTest, ClearStream_ExternalFallback) {
  444. this->AddMockDecoder(kDecoder1, kClearOnly);
  445. this->AddMockDecoder(kDecoder2, kClearOnly);
  446. this->UseClearDecoderConfig();
  447. this->CreateDecoderSelector();
  448. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  449. this->SelectNextDecoder();
  450. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  451. this->SelectNextDecoder();
  452. EXPECT_CALL(*this, NoDecoderSelected());
  453. this->SelectNextDecoder();
  454. }
  455. TYPED_TEST(DecoderSelectorTest, ClearStream_FinalizeDecoderSelection) {
  456. this->AddMockDecoder(kDecoder1, kClearOnly);
  457. this->AddMockDecoder(kDecoder2, kClearOnly);
  458. this->UseClearDecoderConfig();
  459. this->CreateDecoderSelector();
  460. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  461. this->SelectNextDecoder();
  462. this->FinalizeDecoderSelection();
  463. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  464. this->SelectNextDecoder();
  465. }
  466. // Tests that platform decoders are prioritized for
  467. // high-quality configs, retaining their relative order.
  468. TYPED_TEST(DecoderSelectorTest, ClearStream_PrioritizePlatformDecoders) {
  469. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  470. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  471. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  472. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  473. this->UseHighQualityClearDecoderConfig();
  474. this->CreateDecoderSelector();
  475. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  476. base::BindRepeating(TypeParam::MockDecoderPriorityCB));
  477. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  478. this->SelectNextDecoder();
  479. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  480. this->SelectNextDecoder();
  481. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  482. this->SelectNextDecoder();
  483. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  484. this->SelectNextDecoder();
  485. EXPECT_CALL(*this, NoDecoderSelected());
  486. this->SelectNextDecoder();
  487. }
  488. // Tests that non-platform decoders are prioritized for
  489. // normal-quality configs, retaining their relative order.
  490. TYPED_TEST(DecoderSelectorTest, ClearStream_DeprioritizePlatformDecoders) {
  491. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  492. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  493. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  494. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  495. this->UseClearDecoderConfig();
  496. this->CreateDecoderSelector();
  497. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  498. base::BindRepeating(TypeParam::MockDecoderPriorityCB));
  499. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  500. this->SelectNextDecoder();
  501. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  502. this->SelectNextDecoder();
  503. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  504. this->SelectNextDecoder();
  505. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  506. this->SelectNextDecoder();
  507. EXPECT_CALL(*this, NoDecoderSelected());
  508. this->SelectNextDecoder();
  509. }
  510. // Tests that platform and non-platform decoders remain in the order they are
  511. // given for a priority callback returning 'kNormal'.
  512. TYPED_TEST(DecoderSelectorTest,
  513. ClearStream_NormalPriorityCallbackRetainsGivenOrder) {
  514. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  515. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  516. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  517. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  518. this->UseClearDecoderConfig();
  519. this->CreateDecoderSelector();
  520. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  521. base::BindRepeating(TypeParam::NormalDecoderPriorityCB));
  522. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  523. this->SelectNextDecoder();
  524. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  525. this->SelectNextDecoder();
  526. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  527. this->SelectNextDecoder();
  528. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  529. this->SelectNextDecoder();
  530. EXPECT_CALL(*this, NoDecoderSelected());
  531. this->SelectNextDecoder();
  532. }
  533. TYPED_TEST(DecoderSelectorTest, ClearStream_SkipAllDecoders) {
  534. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  535. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  536. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  537. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  538. this->UseClearDecoderConfig();
  539. this->CreateDecoderSelector();
  540. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  541. base::BindRepeating(TypeParam::SkipDecoderPriorityCB));
  542. EXPECT_CALL(*this, NoDecoderSelected());
  543. this->SelectNextDecoder();
  544. }
  545. TYPED_TEST(DecoderSelectorTest, ClearStream_ForceHardwareDecoders) {
  546. base::test::ScopedFeatureList features;
  547. features.InitAndEnableFeature(TypeParam::ForceHardwareDecodersFeature());
  548. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  549. this->AddMockDecoder(kDecoder2, kClearOnly);
  550. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  551. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  552. this->UseClearDecoderConfig();
  553. this->CreateDecoderSelector();
  554. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  555. this->SelectNextDecoder();
  556. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  557. this->SelectNextDecoder();
  558. EXPECT_CALL(*this, NoDecoderSelected());
  559. this->SelectNextDecoder();
  560. }
  561. // Tests the production predicate for `DecoderSelector<DemuxerStream::VIDEO>`
  562. TEST_F(VideoDecoderSelectorTest, ClearStream_PrioritizeSoftwareDecoders) {
  563. base::test::ScopedFeatureList features;
  564. features.InitAndEnableFeature(kResolutionBasedDecoderPriority);
  565. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  566. this->AddMockDecoder(kDecoder2, kClearOnly);
  567. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  568. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  569. // Create a clear config that will cause software decoders to be
  570. // prioritized on any platform.
  571. this->demuxer_stream_.set_video_decoder_config(
  572. TestVideoConfig::Custom(gfx::Size(64, 64)));
  573. this->CreateDecoderSelector();
  574. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  575. this->SelectNextDecoder();
  576. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  577. this->SelectNextDecoder();
  578. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  579. this->SelectNextDecoder();
  580. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  581. this->SelectNextDecoder();
  582. EXPECT_CALL(*this, NoDecoderSelected());
  583. this->SelectNextDecoder();
  584. }
  585. // Tests the production predicate for `DecoderSelector<DemuxerStream::VIDEO>`
  586. TEST_F(VideoDecoderSelectorTest, ClearStream_PrioritizePlatformDecoders) {
  587. base::test::ScopedFeatureList features;
  588. features.InitAndEnableFeature(kResolutionBasedDecoderPriority);
  589. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  590. this->AddMockDecoder(kDecoder2, kClearOnly);
  591. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  592. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  593. // Create a clear config that will cause hardware decoders to be prioritized
  594. // on any platform.
  595. this->demuxer_stream_.set_video_decoder_config(
  596. TestVideoConfig::Custom(gfx::Size(4096, 4096)));
  597. this->CreateDecoderSelector();
  598. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  599. this->SelectNextDecoder();
  600. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  601. this->SelectNextDecoder();
  602. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  603. this->SelectNextDecoder();
  604. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  605. this->SelectNextDecoder();
  606. EXPECT_CALL(*this, NoDecoderSelected());
  607. this->SelectNextDecoder();
  608. }
  609. // Tests for encrypted streams.
  610. // Tests that non-decrypting decoders are filtered out by DecoderSelector
  611. // before being initialized.
  612. TYPED_TEST(DecoderSelectorTest,
  613. EncryptedStream_NoDecryptor_DecodersNotInitialized) {
  614. using MockDecoderArgs =
  615. typename DecoderSelectorTest<TypeParam>::MockDecoderArgs;
  616. auto args = MockDecoderArgs::Create(kDecoder1, kClearOnly);
  617. args.expect_not_initialized = true;
  618. this->AddMockDecoder(std::move(args));
  619. args = MockDecoderArgs::Create(kDecoder2, kClearOnly);
  620. args.expect_not_initialized = true;
  621. this->AddMockDecoder(std::move(args));
  622. this->UseEncryptedDecoderConfig();
  623. this->CreateDecoderSelector();
  624. EXPECT_CALL(*this, NoDecoderSelected());
  625. this->SelectNextDecoder();
  626. }
  627. // Tests that for an encrypted stream, platform decoders are prioritized for
  628. // high-quality configs, retaining their relative order.
  629. TYPED_TEST(DecoderSelectorTest, EncryptedStream_PrioritizePlatformDecoders) {
  630. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  631. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  632. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  633. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  634. this->UseHighQualityEncryptedDecoderConfig();
  635. this->CreateDecoderSelector();
  636. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  637. base::BindRepeating(TypeParam::MockDecoderPriorityCB));
  638. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  639. this->SelectNextDecoder();
  640. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  641. this->SelectNextDecoder();
  642. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  643. this->SelectNextDecoder();
  644. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  645. this->SelectNextDecoder();
  646. EXPECT_CALL(*this, NoDecoderSelected());
  647. this->SelectNextDecoder();
  648. }
  649. // Tests that for an encrypted stream, non-platform decoders are prioritized for
  650. // normal-quality configs, retaining their relative order.
  651. TYPED_TEST(DecoderSelectorTest, EncryptedStream_DeprioritizePlatformDecoders) {
  652. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  653. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  654. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  655. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  656. this->UseEncryptedDecoderConfig();
  657. this->CreateDecoderSelector();
  658. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  659. base::BindRepeating(TypeParam::MockDecoderPriorityCB));
  660. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  661. this->SelectNextDecoder();
  662. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  663. this->SelectNextDecoder();
  664. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  665. this->SelectNextDecoder();
  666. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  667. this->SelectNextDecoder();
  668. EXPECT_CALL(*this, NoDecoderSelected());
  669. this->SelectNextDecoder();
  670. }
  671. // Tests that platform and non-platform decoders remain in the order they are
  672. // given for a priority callback returning 'kNormal'.
  673. TYPED_TEST(DecoderSelectorTest,
  674. EncryptedStream_NormalPriorityCallbackRetainsGivenOrder) {
  675. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  676. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  677. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  678. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  679. this->UseEncryptedDecoderConfig();
  680. this->CreateDecoderSelector();
  681. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  682. base::BindRepeating(TypeParam::NormalDecoderPriorityCB));
  683. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  684. this->SelectNextDecoder();
  685. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  686. this->SelectNextDecoder();
  687. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  688. this->SelectNextDecoder();
  689. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  690. this->SelectNextDecoder();
  691. EXPECT_CALL(*this, NoDecoderSelected());
  692. this->SelectNextDecoder();
  693. }
  694. TYPED_TEST(DecoderSelectorTest, EncryptedStream_SkipAllDecoders) {
  695. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  696. this->AddMockDecoder(kDecoder2, kAlwaysSucceed);
  697. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  698. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  699. this->UseEncryptedDecoderConfig();
  700. this->CreateDecoderSelector();
  701. this->decoder_selector_->OverrideDecoderPriorityCBForTesting(
  702. base::BindRepeating(TypeParam::SkipDecoderPriorityCB));
  703. EXPECT_CALL(*this, NoDecoderSelected());
  704. this->SelectNextDecoder();
  705. }
  706. TYPED_TEST(DecoderSelectorTest, EncryptedStream_ForceHardwareDecoders) {
  707. base::test::ScopedFeatureList features;
  708. features.InitAndEnableFeature(TypeParam::ForceHardwareDecodersFeature());
  709. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  710. this->AddMockDecoder(kDecoder2, kClearOnly);
  711. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  712. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  713. this->UseEncryptedDecoderConfig();
  714. this->CreateDecoderSelector();
  715. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  716. this->SelectNextDecoder();
  717. EXPECT_CALL(*this, NoDecoderSelected());
  718. this->SelectNextDecoder();
  719. }
  720. TYPED_TEST(DecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) {
  721. this->AddMockDecoder(kDecoder1, kClearOnly);
  722. this->CreateCdmContext(kNoDecryptor);
  723. this->UseEncryptedDecoderConfig();
  724. this->CreateDecoderSelector();
  725. EXPECT_CALL(*this, NoDecoderSelected());
  726. this->SelectNextDecoder();
  727. }
  728. TYPED_TEST(DecoderSelectorTest, EncryptedStream_NoDecryptor_InternalFallback) {
  729. this->AddMockDecoder(kDecoder1, kClearOnly);
  730. this->AddMockDecoder(kDecoder2, kEncryptedOnly);
  731. this->CreateCdmContext(kNoDecryptor);
  732. this->UseEncryptedDecoderConfig();
  733. this->CreateDecoderSelector();
  734. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  735. this->SelectNextDecoder();
  736. }
  737. TYPED_TEST(DecoderSelectorTest, EncryptedStream_NoDecryptor_ExternalFallback) {
  738. this->AddMockDecoder(kDecoder1, kEncryptedOnly);
  739. this->AddMockDecoder(kDecoder2, kEncryptedOnly);
  740. this->CreateCdmContext(kNoDecryptor);
  741. this->UseEncryptedDecoderConfig();
  742. this->CreateDecoderSelector();
  743. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  744. this->SelectNextDecoder();
  745. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  746. this->SelectNextDecoder();
  747. }
  748. TYPED_TEST(DecoderSelectorTest,
  749. EncryptedStream_NoDecryptor_FinalizeDecoderSelection) {
  750. this->AddMockDecoder(kDecoder1, kEncryptedOnly);
  751. this->AddMockDecoder(kDecoder2, kEncryptedOnly);
  752. this->CreateCdmContext(kNoDecryptor);
  753. this->UseEncryptedDecoderConfig();
  754. this->CreateDecoderSelector();
  755. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  756. this->SelectNextDecoder();
  757. this->FinalizeDecoderSelection();
  758. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  759. this->SelectNextDecoder();
  760. }
  761. TYPED_TEST(DecoderSelectorTest, EncryptedStream_DecryptOnly_NoDecoder) {
  762. this->CreateCdmContext(kDecryptOnly);
  763. this->UseEncryptedDecoderConfig();
  764. this->CreateDecoderSelector();
  765. EXPECT_CALL(*this, NoDecoderSelected());
  766. this->SelectNextDecoder();
  767. }
  768. TYPED_TEST(DecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
  769. this->AddMockDecoder(kDecoder1, kClearOnly);
  770. this->CreateCdmContext(kDecryptOnly);
  771. this->UseEncryptedDecoderConfig();
  772. this->CreateDecoderSelector();
  773. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  774. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()));
  775. this->SelectNextDecoder();
  776. }
  777. TYPED_TEST(DecoderSelectorTest, EncryptedStream_DecryptOnly_InternalFallback) {
  778. this->AddMockDecoder(kDecoder1, kAlwaysFail);
  779. this->AddMockDecoder(kDecoder2, kClearOnly);
  780. this->CreateCdmContext(kDecryptOnly);
  781. this->UseEncryptedDecoderConfig();
  782. this->CreateDecoderSelector();
  783. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  784. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()));
  785. this->SelectNextDecoder();
  786. }
  787. TYPED_TEST(DecoderSelectorTest,
  788. EncryptedStream_DecryptOnly_FinalizeDecoderSelection) {
  789. this->AddMockDecoder(kDecoder1, kClearOnly);
  790. this->AddMockDecoder(kDecoder2, kClearOnly);
  791. this->CreateCdmContext(kDecryptOnly);
  792. this->UseEncryptedDecoderConfig();
  793. this->CreateDecoderSelector();
  794. std::unique_ptr<DecryptingDemuxerStream> saved_dds;
  795. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  796. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()))
  797. .WillOnce([&](std::unique_ptr<DecryptingDemuxerStream> dds) {
  798. saved_dds = std::move(dds);
  799. });
  800. this->SelectNextDecoder();
  801. this->FinalizeDecoderSelection();
  802. // DDS is reused.
  803. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  804. this->SelectNextDecoder();
  805. }
  806. TYPED_TEST(DecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
  807. this->AddDecryptingDecoder();
  808. this->AddMockDecoder(kDecoder1, kClearOnly);
  809. this->CreateCdmContext(kDecryptAndDecode);
  810. this->UseEncryptedDecoderConfig();
  811. this->CreateDecoderSelector();
  812. #if !BUILDFLAG(IS_ANDROID)
  813. // A DecryptingVideoDecoder will be created and selected. The clear decoder
  814. // should not be touched at all. No DecryptingDemuxerStream should be
  815. // created.
  816. EXPECT_CALL(*this, OnDecoderSelected(TestFixture::DecoderType::kDecrypting));
  817. #else
  818. // A DecryptingDemuxerStream will be created. The clear decoder will be
  819. // initialized and returned.
  820. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  821. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()));
  822. #endif // !BUILDFLAG(IS_ANDROID)
  823. this->SelectNextDecoder();
  824. }
  825. TYPED_TEST(DecoderSelectorTest,
  826. EncryptedStream_DecryptAndDecode_ExternalFallback) {
  827. this->AddDecryptingDecoder();
  828. this->AddMockDecoder(kDecoder1, kClearOnly);
  829. this->AddMockDecoder(kDecoder2, kClearOnly);
  830. this->CreateCdmContext(kDecryptAndDecode);
  831. this->UseEncryptedDecoderConfig();
  832. this->CreateDecoderSelector();
  833. #if !BUILDFLAG(IS_ANDROID)
  834. // DecryptingDecoder is selected immediately.
  835. EXPECT_CALL(*this, OnDecoderSelected(TestFixture::DecoderType::kDecrypting));
  836. this->SelectNextDecoder();
  837. #endif // !BUILDFLAG(IS_ANDROID)
  838. // On fallback, a DecryptingDemuxerStream will be created.
  839. std::unique_ptr<DecryptingDemuxerStream> saved_dds;
  840. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  841. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()))
  842. .WillOnce([&](std::unique_ptr<DecryptingDemuxerStream> dds) {
  843. saved_dds = std::move(dds);
  844. });
  845. this->SelectNextDecoder();
  846. // The DecryptingDemuxerStream should be reused.
  847. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  848. this->SelectNextDecoder();
  849. }
  850. TYPED_TEST(DecoderSelectorTest, ClearToEncryptedStream_DecryptOnly) {
  851. this->AddMockDecoder(kDecoder1, kClearOnly);
  852. this->CreateCdmContext(kDecryptOnly);
  853. this->UseClearDecoderConfig();
  854. this->CreateDecoderSelector();
  855. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  856. this->SelectNextDecoder();
  857. this->FinalizeDecoderSelection();
  858. this->UseEncryptedDecoderConfig();
  859. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  860. EXPECT_CALL(*this, OnDemuxerStreamSelected(NotNull()));
  861. this->SelectNextDecoder();
  862. }
  863. // Tests the production predicate for `DecoderSelector<DemuxerStream::VIDEO>`
  864. TEST_F(VideoDecoderSelectorTest, EncryptedStream_PrioritizeSoftwareDecoders) {
  865. base::test::ScopedFeatureList features;
  866. features.InitAndEnableFeature(kResolutionBasedDecoderPriority);
  867. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  868. this->AddMockDecoder(kDecoder2, kClearOnly);
  869. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  870. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  871. // Create an encrypted config that will cause software decoders to be
  872. // prioritized on any platform.
  873. this->demuxer_stream_.set_video_decoder_config(
  874. TestVideoConfig::CustomEncrypted(gfx::Size(64, 64)));
  875. this->CreateDecoderSelector();
  876. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  877. this->SelectNextDecoder();
  878. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  879. this->SelectNextDecoder();
  880. EXPECT_CALL(*this, NoDecoderSelected());
  881. this->SelectNextDecoder();
  882. }
  883. // Tests the production predicate for `DecoderSelector<DemuxerStream::VIDEO>`
  884. TEST_F(VideoDecoderSelectorTest, EncryptedStream_PrioritizePlatformDecoders) {
  885. base::test::ScopedFeatureList features;
  886. features.InitAndEnableFeature(kResolutionBasedDecoderPriority);
  887. this->AddMockPlatformDecoder(kDecoder1, kClearOnly);
  888. this->AddMockDecoder(kDecoder2, kClearOnly);
  889. this->AddMockPlatformDecoder(kDecoder3, kAlwaysSucceed);
  890. this->AddMockDecoder(kDecoder4, kAlwaysSucceed);
  891. // Create an encrypted config that will cause hardware decoders to be
  892. // prioritized on any platform.
  893. this->demuxer_stream_.set_video_decoder_config(
  894. TestVideoConfig::CustomEncrypted(gfx::Size(4096, 4096)));
  895. this->CreateDecoderSelector();
  896. EXPECT_CALL(*this, OnDecoderSelected(kDecoder3));
  897. this->SelectNextDecoder();
  898. EXPECT_CALL(*this, OnDecoderSelected(kDecoder4));
  899. this->SelectNextDecoder();
  900. EXPECT_CALL(*this, NoDecoderSelected());
  901. this->SelectNextDecoder();
  902. }
  903. // Tests we always use resolution-based rules for RTC.
  904. TEST_F(VideoDecoderSelectorTest, RTC_UseResolutionRuleWithoutSwitch) {
  905. // Turn off `kResolutionBasedDecoderPriority`, since rtc should override it.
  906. base::test::ScopedFeatureList features;
  907. features.InitAndDisableFeature(kResolutionBasedDecoderPriority);
  908. // Add the non-platform decoder earlier, but expect the platform one.
  909. this->AddMockDecoder(kDecoder1, kAlwaysSucceed);
  910. this->AddMockPlatformDecoder(kDecoder2, kAlwaysSucceed);
  911. auto config = TestVideoConfig::Custom(gfx::Size(4096, 4096));
  912. config.set_is_rtc(true);
  913. this->demuxer_stream_.set_video_decoder_config(config);
  914. this->CreateDecoderSelector();
  915. EXPECT_CALL(*this, OnDecoderSelected(kDecoder2));
  916. this->SelectNextDecoder();
  917. }
  918. // Non-platform decoders should be used for RTC unless enabled by a switch.
  919. TEST_F(VideoDecoderSelectorTest, RTC_SkipNonPlatformDecodersWithoutSwitch) {
  920. base::test::ScopedFeatureList features;
  921. features.InitAndDisableFeature(kExposeSwDecodersToWebRTC);
  922. // Add a non-platform decoder, which it should not use.
  923. this->AddMockDecoder(kDecoder1, kAlwaysSucceed);
  924. auto config = TestVideoConfig::Custom(gfx::Size(100, 100));
  925. config.set_is_rtc(true);
  926. this->demuxer_stream_.set_video_decoder_config(config);
  927. this->CreateDecoderSelector();
  928. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1)).Times(0);
  929. this->SelectNextDecoder();
  930. }
  931. // Platform decoders should be allowed for RTC without the sw switch.
  932. TEST_F(VideoDecoderSelectorTest, RTC_AllowPlatformDecodersWithoutSwitch) {
  933. base::test::ScopedFeatureList features;
  934. features.InitAndDisableFeature(kExposeSwDecodersToWebRTC);
  935. // Add a platform decoder, which it should use.
  936. this->AddMockPlatformDecoder(kDecoder1, kAlwaysSucceed);
  937. auto config = TestVideoConfig::Custom(gfx::Size(100, 100));
  938. config.set_is_rtc(true);
  939. this->demuxer_stream_.set_video_decoder_config(config);
  940. this->CreateDecoderSelector();
  941. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  942. this->SelectNextDecoder();
  943. }
  944. // Non-platform decoders should be allowed for RTC if enabled by a switch.
  945. TEST_F(VideoDecoderSelectorTest, RTC_AllowNonPlatformDecodersWithSwitch) {
  946. base::test::ScopedFeatureList features;
  947. features.InitAndEnableFeature(kExposeSwDecodersToWebRTC);
  948. // Add a non-platform decoder, which it should use.
  949. this->AddMockDecoder(kDecoder1, kAlwaysSucceed);
  950. auto config = TestVideoConfig::Custom(gfx::Size(100, 100));
  951. config.set_is_rtc(true);
  952. this->demuxer_stream_.set_video_decoder_config(config);
  953. this->CreateDecoderSelector();
  954. EXPECT_CALL(*this, OnDecoderSelected(kDecoder1));
  955. this->SelectNextDecoder();
  956. }
  957. } // namespace media