fake_demuxer_stream_unittest.cc 10.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. // Copyright (c) 2012 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 "media/base/fake_demuxer_stream.h"
  5. #include <memory>
  6. #include "base/bind.h"
  7. #include "base/run_loop.h"
  8. #include "base/test/task_environment.h"
  9. #include "media/base/decoder_buffer.h"
  10. #include "media/base/demuxer_stream.h"
  11. #include "testing/gtest/include/gtest/gtest.h"
  12. namespace media {
  13. const int kNumBuffersInOneConfig = 9;
  14. const int kNumBuffersToReadFirst = 5;
  15. const int kNumConfigs = 3;
  16. static_assert(kNumBuffersToReadFirst < kNumBuffersInOneConfig,
  17. "do not read too many buffers");
  18. static_assert(kNumConfigs > 0,
  19. "need multiple configs to trigger config change");
  20. class FakeDemuxerStreamTest : public testing::Test {
  21. public:
  22. FakeDemuxerStreamTest()
  23. : status_(DemuxerStream::kAborted),
  24. read_pending_(false),
  25. num_buffers_received_(0) {}
  26. FakeDemuxerStreamTest(const FakeDemuxerStreamTest&) = delete;
  27. FakeDemuxerStreamTest& operator=(const FakeDemuxerStreamTest&) = delete;
  28. ~FakeDemuxerStreamTest() override = default;
  29. void BufferReady(DemuxerStream::Status status,
  30. scoped_refptr<DecoderBuffer> buffer) {
  31. DCHECK(read_pending_);
  32. read_pending_ = false;
  33. status_ = status;
  34. if (status == DemuxerStream::kOk && !buffer->end_of_stream())
  35. num_buffers_received_++;
  36. buffer_ = std::move(buffer);
  37. }
  38. enum ReadResult { OK, ABORTED, CONFIG_CHANGED, READ_ERROR, EOS, PENDING };
  39. void EnterNormalReadState() {
  40. stream_ = std::make_unique<FakeDemuxerStream>(
  41. kNumConfigs, kNumBuffersInOneConfig, false);
  42. for (int i = 0; i < kNumBuffersToReadFirst; ++i)
  43. ReadAndExpect(OK);
  44. DCHECK_EQ(kNumBuffersToReadFirst, num_buffers_received_);
  45. }
  46. void EnterBeforeEOSState() {
  47. stream_ =
  48. std::make_unique<FakeDemuxerStream>(1, kNumBuffersInOneConfig, false);
  49. for (int i = 0; i < kNumBuffersInOneConfig; ++i)
  50. ReadAndExpect(OK);
  51. DCHECK_EQ(kNumBuffersInOneConfig, num_buffers_received_);
  52. }
  53. void ExpectReadResult(ReadResult result) {
  54. switch (result) {
  55. case OK:
  56. EXPECT_FALSE(read_pending_);
  57. EXPECT_EQ(DemuxerStream::kOk, status_);
  58. ASSERT_TRUE(buffer_.get());
  59. EXPECT_FALSE(buffer_->end_of_stream());
  60. break;
  61. case ABORTED:
  62. EXPECT_FALSE(read_pending_);
  63. EXPECT_EQ(DemuxerStream::kAborted, status_);
  64. EXPECT_FALSE(buffer_.get());
  65. break;
  66. case CONFIG_CHANGED:
  67. EXPECT_TRUE(stream_->SupportsConfigChanges());
  68. EXPECT_FALSE(read_pending_);
  69. EXPECT_EQ(DemuxerStream::kConfigChanged, status_);
  70. EXPECT_FALSE(buffer_.get());
  71. break;
  72. case READ_ERROR:
  73. EXPECT_FALSE(read_pending_);
  74. EXPECT_EQ(DemuxerStream::kError, status_);
  75. EXPECT_FALSE(buffer_.get());
  76. break;
  77. case EOS:
  78. EXPECT_FALSE(read_pending_);
  79. EXPECT_EQ(DemuxerStream::kOk, status_);
  80. ASSERT_TRUE(buffer_.get());
  81. EXPECT_TRUE(buffer_->end_of_stream());
  82. break;
  83. case PENDING:
  84. EXPECT_TRUE(read_pending_);
  85. break;
  86. }
  87. }
  88. void ReadAndExpect(ReadResult result) {
  89. EXPECT_FALSE(read_pending_);
  90. read_pending_ = true;
  91. stream_->Read(base::BindOnce(&FakeDemuxerStreamTest::BufferReady,
  92. base::Unretained(this)));
  93. base::RunLoop().RunUntilIdle();
  94. ExpectReadResult(result);
  95. }
  96. void ReadUntilPending() {
  97. while (true) {
  98. read_pending_ = true;
  99. stream_->Read(base::BindOnce(&FakeDemuxerStreamTest::BufferReady,
  100. base::Unretained(this)));
  101. base::RunLoop().RunUntilIdle();
  102. if (read_pending_)
  103. break;
  104. }
  105. }
  106. void SatisfyReadAndExpect(ReadResult result) {
  107. EXPECT_TRUE(read_pending_);
  108. stream_->SatisfyRead();
  109. base::RunLoop().RunUntilIdle();
  110. ExpectReadResult(result);
  111. }
  112. void Reset() {
  113. bool had_read_pending = read_pending_;
  114. stream_->Reset();
  115. base::RunLoop().RunUntilIdle();
  116. EXPECT_FALSE(read_pending_);
  117. if (had_read_pending)
  118. ExpectReadResult(ABORTED);
  119. }
  120. void Error() {
  121. bool had_read_pending = read_pending_;
  122. stream_->Error();
  123. base::RunLoop().RunUntilIdle();
  124. EXPECT_FALSE(read_pending_);
  125. if (had_read_pending)
  126. ExpectReadResult(READ_ERROR);
  127. }
  128. void ReadAllBuffers(int num_configs, int num_buffers_in_one_config) {
  129. DCHECK_EQ(0, num_buffers_received_);
  130. for (int i = 0; i < num_configs; ++i) {
  131. for (int j = 0; j < num_buffers_in_one_config; ++j) {
  132. ReadAndExpect(OK);
  133. EXPECT_EQ(num_buffers_received_, stream_->num_buffers_returned());
  134. }
  135. if (i == num_configs - 1)
  136. ReadAndExpect(EOS);
  137. else
  138. ReadAndExpect(CONFIG_CHANGED);
  139. }
  140. // Will always get EOS after we hit EOS.
  141. ReadAndExpect(EOS);
  142. EXPECT_EQ(num_configs * num_buffers_in_one_config, num_buffers_received_);
  143. }
  144. void TestRead(int num_configs,
  145. int num_buffers_in_one_config,
  146. bool is_encrypted) {
  147. stream_ = std::make_unique<FakeDemuxerStream>(
  148. num_configs, num_buffers_in_one_config, is_encrypted);
  149. const VideoDecoderConfig& config = stream_->video_decoder_config();
  150. EXPECT_TRUE(config.IsValidConfig());
  151. EXPECT_EQ(is_encrypted, config.is_encrypted());
  152. ReadAllBuffers(num_configs, num_buffers_in_one_config);
  153. }
  154. base::test::SingleThreadTaskEnvironment task_environment_;
  155. std::unique_ptr<FakeDemuxerStream> stream_;
  156. DemuxerStream::Status status_;
  157. scoped_refptr<DecoderBuffer> buffer_;
  158. bool read_pending_;
  159. int num_buffers_received_;
  160. };
  161. TEST_F(FakeDemuxerStreamTest, Read_OneConfig) {
  162. TestRead(1, 5, false);
  163. }
  164. TEST_F(FakeDemuxerStreamTest, Read_MultipleConfigs) {
  165. TestRead(3, 5, false);
  166. }
  167. TEST_F(FakeDemuxerStreamTest, Read_OneBufferPerConfig) {
  168. TestRead(3, 1, false);
  169. }
  170. TEST_F(FakeDemuxerStreamTest, Read_Encrypted) {
  171. TestRead(6, 3, true);
  172. }
  173. TEST_F(FakeDemuxerStreamTest, HoldRead_Normal) {
  174. EnterNormalReadState();
  175. stream_->HoldNextRead();
  176. ReadAndExpect(PENDING);
  177. SatisfyReadAndExpect(OK);
  178. }
  179. TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeConfigChanged) {
  180. EnterNormalReadState();
  181. stream_->HoldNextConfigChangeRead();
  182. ReadUntilPending();
  183. SatisfyReadAndExpect(CONFIG_CHANGED);
  184. }
  185. TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeEOS) {
  186. EnterBeforeEOSState();
  187. stream_->HoldNextRead();
  188. ReadAndExpect(PENDING);
  189. SatisfyReadAndExpect(EOS);
  190. }
  191. TEST_F(FakeDemuxerStreamTest, Reset_Normal) {
  192. EnterNormalReadState();
  193. Reset();
  194. ReadAndExpect(OK);
  195. }
  196. TEST_F(FakeDemuxerStreamTest, Reset_AfterHoldRead) {
  197. EnterNormalReadState();
  198. stream_->HoldNextRead();
  199. Reset();
  200. ReadAndExpect(OK);
  201. }
  202. TEST_F(FakeDemuxerStreamTest, Reset_DuringPendingRead) {
  203. EnterNormalReadState();
  204. stream_->HoldNextRead();
  205. ReadAndExpect(PENDING);
  206. Reset();
  207. ReadAndExpect(OK);
  208. }
  209. TEST_F(FakeDemuxerStreamTest, Reset_BeforeConfigChanged) {
  210. EnterNormalReadState();
  211. stream_->HoldNextConfigChangeRead();
  212. ReadUntilPending();
  213. Reset();
  214. ReadAndExpect(CONFIG_CHANGED);
  215. }
  216. TEST_F(FakeDemuxerStreamTest, Reset_BeforeEOS) {
  217. EnterBeforeEOSState();
  218. stream_->HoldNextRead();
  219. ReadAndExpect(PENDING);
  220. Reset();
  221. ReadAndExpect(EOS);
  222. }
  223. TEST_F(FakeDemuxerStreamTest, Error_Normal) {
  224. EnterNormalReadState();
  225. Error();
  226. ReadAndExpect(OK);
  227. }
  228. TEST_F(FakeDemuxerStreamTest, Error_AfterHoldRead) {
  229. EnterNormalReadState();
  230. stream_->HoldNextRead();
  231. Error();
  232. ReadAndExpect(OK);
  233. }
  234. TEST_F(FakeDemuxerStreamTest, Error_BeforeConfigChanged) {
  235. EnterNormalReadState();
  236. stream_->HoldNextConfigChangeRead();
  237. ReadUntilPending();
  238. Error();
  239. ReadAndExpect(CONFIG_CHANGED);
  240. }
  241. TEST_F(FakeDemuxerStreamTest, Error_BeforeEOS) {
  242. EnterBeforeEOSState();
  243. stream_->HoldNextRead();
  244. ReadAndExpect(PENDING);
  245. Error();
  246. ReadAndExpect(EOS);
  247. }
  248. TEST_F(FakeDemuxerStreamTest, NoConfigChanges) {
  249. stream_ =
  250. std::make_unique<FakeDemuxerStream>(1, kNumBuffersInOneConfig, false);
  251. EXPECT_FALSE(stream_->SupportsConfigChanges());
  252. for (int i = 0; i < kNumBuffersInOneConfig; ++i)
  253. ReadAndExpect(OK);
  254. ReadAndExpect(EOS);
  255. }
  256. TEST_F(FakeDemuxerStreamTest, SeekToStart_Normal) {
  257. EnterNormalReadState();
  258. stream_->SeekToStart();
  259. num_buffers_received_ = 0;
  260. ReadAllBuffers(kNumConfigs, kNumBuffersInOneConfig);
  261. }
  262. TEST_F(FakeDemuxerStreamTest, SeekToStart_BeforeEOS) {
  263. EnterBeforeEOSState();
  264. stream_->SeekToStart();
  265. num_buffers_received_ = 0;
  266. ReadAllBuffers(1, kNumBuffersInOneConfig);
  267. }
  268. TEST_F(FakeDemuxerStreamTest, SeekToStart_AfterEOS) {
  269. TestRead(3, 5, false);
  270. stream_->SeekToStart();
  271. num_buffers_received_ = 0;
  272. ReadAllBuffers(3, 5);
  273. }
  274. TEST_F(FakeDemuxerStreamTest, DemuxerStream_GetTypeName) {
  275. EXPECT_TRUE(DemuxerStream::GetTypeName(DemuxerStream::Type::AUDIO) ==
  276. std::string("audio"));
  277. EXPECT_TRUE(DemuxerStream::GetTypeName(DemuxerStream::Type::VIDEO) ==
  278. std::string("video"));
  279. EXPECT_TRUE(DemuxerStream::GetTypeName(DemuxerStream::Type::TEXT) ==
  280. std::string("text"));
  281. EXPECT_TRUE(DemuxerStream::GetTypeName(DemuxerStream::Type::UNKNOWN) ==
  282. std::string("unknown"));
  283. }
  284. TEST_F(FakeDemuxerStreamTest, DemuxerStream_GetStatusName) {
  285. EXPECT_TRUE(DemuxerStream::GetStatusName(DemuxerStream::Status::kOk) ==
  286. std::string("okay"));
  287. EXPECT_TRUE(DemuxerStream::GetStatusName(DemuxerStream::Status::kAborted) ==
  288. std::string("aborted"));
  289. EXPECT_TRUE(
  290. DemuxerStream::GetStatusName(DemuxerStream::Status::kConfigChanged) ==
  291. std::string("config_changed"));
  292. EXPECT_TRUE(DemuxerStream::GetStatusName(DemuxerStream::Status::kError) ==
  293. std::string("error"));
  294. }
  295. TEST_F(FakeDemuxerStreamTest, DemuxerStream_GetLivenessName) {
  296. EXPECT_TRUE(GetStreamLivenessName(StreamLiveness::kUnknown) ==
  297. std::string("unknown"));
  298. EXPECT_TRUE(GetStreamLivenessName(StreamLiveness::kRecorded) ==
  299. std::string("recorded"));
  300. EXPECT_TRUE(GetStreamLivenessName(StreamLiveness::kLive) ==
  301. std::string("live"));
  302. }
  303. } // namespace media