h265_decoder_unittest.cc 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534
  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 <cstring>
  5. #include <memory>
  6. #include <string>
  7. #include "base/check.h"
  8. #include "base/containers/queue.h"
  9. #include "base/containers/span.h"
  10. #include "base/files/file_util.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "media/base/test_data_util.h"
  13. #include "media/gpu/h265_decoder.h"
  14. #include "testing/gmock/include/gmock/gmock.h"
  15. #include "testing/gtest/include/gtest/gtest.h"
  16. using ::testing::_;
  17. using ::testing::Args;
  18. using ::testing::Expectation;
  19. using ::testing::InSequence;
  20. using ::testing::Invoke;
  21. using ::testing::MakeMatcher;
  22. using ::testing::Matcher;
  23. using ::testing::MatcherInterface;
  24. using ::testing::MatchResultListener;
  25. using ::testing::Mock;
  26. using ::testing::Return;
  27. using ::testing::WithArg;
  28. namespace media {
  29. namespace {
  30. constexpr char kSpsPps[] = "bear-sps-pps.hevc";
  31. constexpr char kFrame0[] = "bear-frame0.hevc";
  32. constexpr char kFrame1[] = "bear-frame1.hevc";
  33. constexpr char kFrame2[] = "bear-frame2.hevc";
  34. constexpr char kFrame3[] = "bear-frame3.hevc";
  35. constexpr char kFrame4[] = "bear-frame4.hevc";
  36. constexpr char kFrame5[] = "bear-frame5.hevc";
  37. constexpr char k10BitFrame0[] = "bear-320x180-10bit-frame-0.hevc";
  38. constexpr char k10BitFrame1[] = "bear-320x180-10bit-frame-1.hevc";
  39. constexpr char k10BitFrame2[] = "bear-320x180-10bit-frame-2.hevc";
  40. constexpr char k10BitFrame3[] = "bear-320x180-10bit-frame-3.hevc";
  41. constexpr char kYUV444Frame[] = "blackwhite_yuv444p-frame.hevc";
  42. // Checks whether the decrypt config in the picture matches the decrypt config
  43. // passed to this matcher.
  44. MATCHER_P(DecryptConfigMatches, decrypt_config, "") {
  45. return arg->decrypt_config()->Matches(*decrypt_config);
  46. }
  47. MATCHER(SubsampleSizeMatches, "Verify subsample sizes match buffer size") {
  48. const size_t buffer_size = ::testing::get<0>(arg);
  49. const std::vector<SubsampleEntry>& subsamples = ::testing::get<1>(arg);
  50. size_t subsample_total_size = 0;
  51. for (const auto& sample : subsamples) {
  52. subsample_total_size += sample.cypher_bytes;
  53. subsample_total_size += sample.clear_bytes;
  54. }
  55. return subsample_total_size == buffer_size;
  56. }
  57. // To have better description on mismatch.
  58. class HasPocMatcher : public MatcherInterface<scoped_refptr<H265Picture>> {
  59. public:
  60. explicit HasPocMatcher(int expected_poc) : expected_poc_(expected_poc) {}
  61. bool MatchAndExplain(scoped_refptr<H265Picture> p,
  62. MatchResultListener* listener) const override {
  63. if (p->pic_order_cnt_val_ == expected_poc_)
  64. return true;
  65. *listener << "with poc: " << p->pic_order_cnt_val_;
  66. return false;
  67. }
  68. void DescribeTo(std::ostream* os) const override {
  69. *os << "with poc " << expected_poc_;
  70. }
  71. private:
  72. int expected_poc_;
  73. };
  74. Matcher<scoped_refptr<H265Picture>> HasPoc(int expected_poc) {
  75. return MakeMatcher(new HasPocMatcher(expected_poc));
  76. }
  77. } // namespace
  78. class MockH265Accelerator : public H265Decoder::H265Accelerator {
  79. public:
  80. MockH265Accelerator() = default;
  81. MOCK_METHOD0(CreateH265Picture, scoped_refptr<H265Picture>());
  82. MOCK_METHOD5(SubmitFrameMetadata,
  83. Status(const H265SPS* sps,
  84. const H265PPS* pps,
  85. const H265SliceHeader* slice_hdr,
  86. const H265Picture::Vector& ref_pic_list,
  87. scoped_refptr<H265Picture> pic));
  88. MOCK_METHOD(Status,
  89. SubmitSlice,
  90. (const H265SPS* sps,
  91. const H265PPS* pps,
  92. const H265SliceHeader* slice_hdr,
  93. const H265Picture::Vector& ref_pic_list0,
  94. const H265Picture::Vector& ref_pic_list1,
  95. const H265Picture::Vector& ref_pic_set_lt_curr,
  96. const H265Picture::Vector& ref_pic_set_st_curr_after,
  97. const H265Picture::Vector& ref_pic_set_st_curr_before,
  98. scoped_refptr<H265Picture> pic,
  99. const uint8_t* data,
  100. size_t size,
  101. const std::vector<SubsampleEntry>& subsamples));
  102. MOCK_METHOD1(SubmitDecode, Status(scoped_refptr<H265Picture> pic));
  103. MOCK_METHOD1(OutputPicture, bool(scoped_refptr<H265Picture>));
  104. MOCK_METHOD2(SetStream,
  105. Status(base::span<const uint8_t> stream,
  106. const DecryptConfig* decrypt_config));
  107. bool IsChromaSamplingSupported(VideoChromaSampling format) override {
  108. return format == VideoChromaSampling::k420;
  109. }
  110. void Reset() override {}
  111. };
  112. // Test H265Decoder by feeding different h265 frame sequences and make sure it
  113. // behaves as expected.
  114. class H265DecoderTest : public ::testing::Test {
  115. public:
  116. H265DecoderTest() = default;
  117. void SetUp() override;
  118. // Sets the bitstreams to be decoded, frame by frame. The content of each
  119. // file is the encoded bitstream of a single video frame.
  120. void SetInputFrameFiles(const std::vector<std::string>& frame_files);
  121. // Keeps decoding the input bitstream set at |SetInputFrameFiles| until the
  122. // decoder has consumed all bitstreams or returned from
  123. // |H265Decoder::Decode|. Returns the same result as |H265Decoder::Decode|.
  124. // If |set_stream_expect| is true, it will setup EXPECT_CALL for SetStream.
  125. AcceleratedVideoDecoder::DecodeResult Decode(bool set_stream_expect = true);
  126. protected:
  127. std::unique_ptr<H265Decoder> decoder_;
  128. raw_ptr<MockH265Accelerator> accelerator_;
  129. private:
  130. base::queue<std::string> input_frame_files_;
  131. std::string bitstream_;
  132. scoped_refptr<DecoderBuffer> decoder_buffer_;
  133. };
  134. void H265DecoderTest::SetUp() {
  135. auto mock_accelerator = std::make_unique<MockH265Accelerator>();
  136. accelerator_ = mock_accelerator.get();
  137. decoder_.reset(new H265Decoder(std::move(mock_accelerator),
  138. VIDEO_CODEC_PROFILE_UNKNOWN));
  139. // Sets default behaviors for mock methods for convenience.
  140. ON_CALL(*accelerator_, CreateH265Picture()).WillByDefault(Invoke([]() {
  141. return new H265Picture();
  142. }));
  143. ON_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _))
  144. .WillByDefault(Return(H265Decoder::H265Accelerator::Status::kOk));
  145. ON_CALL(*accelerator_, SubmitDecode(_))
  146. .WillByDefault(Return(H265Decoder::H265Accelerator::Status::kOk));
  147. ON_CALL(*accelerator_, OutputPicture(_)).WillByDefault(Return(true));
  148. ON_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  149. .With(Args<10, 11>(SubsampleSizeMatches()))
  150. .WillByDefault(Return(H265Decoder::H265Accelerator::Status::kOk));
  151. ON_CALL(*accelerator_, SetStream(_, _))
  152. .WillByDefault(
  153. Return(H265Decoder::H265Accelerator::Status::kNotSupported));
  154. }
  155. void H265DecoderTest::SetInputFrameFiles(
  156. const std::vector<std::string>& input_frame_files) {
  157. for (auto f : input_frame_files)
  158. input_frame_files_.push(f);
  159. }
  160. AcceleratedVideoDecoder::DecodeResult H265DecoderTest::Decode(
  161. bool set_stream_expect) {
  162. while (true) {
  163. auto result = decoder_->Decode();
  164. int32_t bitstream_id = 0;
  165. if (result != AcceleratedVideoDecoder::kRanOutOfStreamData ||
  166. input_frame_files_.empty())
  167. return result;
  168. auto input_file = GetTestDataFilePath(input_frame_files_.front());
  169. input_frame_files_.pop();
  170. CHECK(base::ReadFileToString(input_file, &bitstream_));
  171. decoder_buffer_ = DecoderBuffer::CopyFrom(
  172. reinterpret_cast<const uint8_t*>(bitstream_.data()), bitstream_.size());
  173. EXPECT_NE(decoder_buffer_.get(), nullptr);
  174. if (set_stream_expect)
  175. EXPECT_CALL(*accelerator_, SetStream(_, _));
  176. decoder_->SetStream(bitstream_id++, *decoder_buffer_);
  177. }
  178. }
  179. TEST_F(H265DecoderTest, DecodeSingleFrame) {
  180. SetInputFrameFiles({kSpsPps, kFrame0});
  181. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  182. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  183. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  184. EXPECT_EQ(8u, decoder_->GetBitDepth());
  185. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  186. // Also test running out of surfaces.
  187. EXPECT_CALL(*accelerator_, CreateH265Picture()).WillOnce(Return(nullptr));
  188. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfSurfaces, Decode());
  189. EXPECT_TRUE(Mock::VerifyAndClearExpectations(&*accelerator_));
  190. {
  191. InSequence sequence;
  192. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(1);
  193. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(1);
  194. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  195. .Times(1);
  196. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0))).Times(1);
  197. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0)));
  198. }
  199. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  200. EXPECT_TRUE(decoder_->Flush());
  201. }
  202. TEST_F(H265DecoderTest, SkipNonIDRFrames) {
  203. SetInputFrameFiles({kSpsPps, kFrame1, kFrame2, kFrame0});
  204. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  205. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  206. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  207. EXPECT_EQ(8u, decoder_->GetBitDepth());
  208. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  209. {
  210. InSequence sequence;
  211. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(1);
  212. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(1);
  213. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  214. .Times(1);
  215. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0))).Times(1);
  216. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0)));
  217. }
  218. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  219. EXPECT_TRUE(decoder_->Flush());
  220. }
  221. TEST_F(H265DecoderTest, DecodeProfileMain) {
  222. SetInputFrameFiles(
  223. {kSpsPps, kFrame0, kFrame1, kFrame2, kFrame3, kFrame4, kFrame5});
  224. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  225. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  226. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  227. EXPECT_EQ(8u, decoder_->GetBitDepth());
  228. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  229. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(6);
  230. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(6);
  231. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  232. .Times(6);
  233. Expectation decode_poc0, decode_poc1, decode_poc2, decode_poc3, decode_poc4,
  234. decode_poc8;
  235. {
  236. InSequence decode_order;
  237. decode_poc0 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)));
  238. decode_poc4 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(4)));
  239. decode_poc2 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(2)));
  240. decode_poc1 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(1)));
  241. decode_poc3 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(3)));
  242. decode_poc8 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(8)));
  243. }
  244. {
  245. InSequence display_order;
  246. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0))).After(decode_poc0);
  247. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(1))).After(decode_poc1);
  248. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(2))).After(decode_poc2);
  249. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(3))).After(decode_poc3);
  250. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(4))).After(decode_poc4);
  251. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(8))).After(decode_poc8);
  252. }
  253. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  254. EXPECT_TRUE(decoder_->Flush());
  255. }
  256. TEST_F(H265DecoderTest, Decode10BitStream) {
  257. SetInputFrameFiles({k10BitFrame0, k10BitFrame1, k10BitFrame2, k10BitFrame3});
  258. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  259. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  260. EXPECT_EQ(gfx::Rect(320, 180), decoder_->GetVisibleRect());
  261. EXPECT_EQ(HEVCPROFILE_MAIN10, decoder_->GetProfile());
  262. EXPECT_EQ(10u, decoder_->GetBitDepth());
  263. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  264. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(4);
  265. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(4);
  266. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  267. .Times(4);
  268. // Two pictures will be kept in the DPB for reordering. The second and third
  269. // pictures should be outputted after feeding the fourth frame.
  270. Expectation decode_poc0, decode_poc1, decode_poc2, decode_poc3;
  271. {
  272. InSequence decode_order;
  273. decode_poc0 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)));
  274. decode_poc3 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(3)));
  275. decode_poc2 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(2)));
  276. decode_poc1 = EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(1)));
  277. }
  278. {
  279. InSequence display_order;
  280. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0))).After(decode_poc0);
  281. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(1))).After(decode_poc1);
  282. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(2))).After(decode_poc2);
  283. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(3))).After(decode_poc3);
  284. }
  285. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  286. EXPECT_TRUE(decoder_->Flush());
  287. }
  288. TEST_F(H265DecoderTest, DenyDecodeNonYUV420) {
  289. // YUV444 frame causes kDecodeError.
  290. SetInputFrameFiles({kYUV444Frame});
  291. ASSERT_EQ(AcceleratedVideoDecoder::kDecodeError, Decode());
  292. }
  293. TEST_F(H265DecoderTest, OutputPictureFailureCausesDecodeToFail) {
  294. // Provide enough data that Decode() will try to output a frame.
  295. SetInputFrameFiles({kSpsPps, kFrame0, kFrame1, kFrame2, kFrame3});
  296. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  297. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(4);
  298. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(3);
  299. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  300. .Times(3);
  301. EXPECT_CALL(*accelerator_, SubmitDecode(_)).Times(3);
  302. EXPECT_CALL(*accelerator_, OutputPicture(_)).WillRepeatedly(Return(false));
  303. EXPECT_EQ(AcceleratedVideoDecoder::kDecodeError, Decode());
  304. }
  305. // Verify that the decryption config is passed to the accelerator.
  306. TEST_F(H265DecoderTest, SetEncryptedStream) {
  307. std::string bitstream, bitstream1, bitstream2;
  308. auto input_file1 = GetTestDataFilePath(kSpsPps);
  309. CHECK(base::ReadFileToString(input_file1, &bitstream1));
  310. auto input_file2 = GetTestDataFilePath(kFrame0);
  311. CHECK(base::ReadFileToString(input_file2, &bitstream2));
  312. bitstream = bitstream1 + bitstream2;
  313. const char kAnyKeyId[] = "any_16byte_keyid";
  314. const char kAnyIv[] = "any_16byte_iv___";
  315. const std::vector<SubsampleEntry> subsamples = {
  316. // No encrypted bytes. This test only checks whether the data is passed
  317. // thru to the acclerator so making this completely clear.
  318. {static_cast<uint32_t>(bitstream.size()), 0},
  319. };
  320. std::unique_ptr<DecryptConfig> decrypt_config =
  321. DecryptConfig::CreateCencConfig(kAnyKeyId, kAnyIv, subsamples);
  322. EXPECT_CALL(*accelerator_,
  323. SubmitFrameMetadata(_, _, _, _,
  324. DecryptConfigMatches(decrypt_config.get())))
  325. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kOk));
  326. EXPECT_CALL(*accelerator_,
  327. SubmitDecode(DecryptConfigMatches(decrypt_config.get())))
  328. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kOk));
  329. auto buffer = DecoderBuffer::CopyFrom(
  330. reinterpret_cast<const uint8_t*>(bitstream.data()), bitstream.size());
  331. ASSERT_NE(buffer.get(), nullptr);
  332. buffer->set_decrypt_config(std::move(decrypt_config));
  333. decoder_->SetStream(0, *buffer);
  334. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, decoder_->Decode());
  335. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  336. EXPECT_EQ(8u, decoder_->GetBitDepth());
  337. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, decoder_->Decode());
  338. EXPECT_TRUE(decoder_->Flush());
  339. }
  340. TEST_F(H265DecoderTest, SubmitFrameMetadataRetry) {
  341. SetInputFrameFiles({kSpsPps, kFrame0});
  342. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  343. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  344. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  345. EXPECT_EQ(8u, decoder_->GetBitDepth());
  346. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  347. {
  348. InSequence sequence;
  349. EXPECT_CALL(*accelerator_, CreateH265Picture());
  350. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _))
  351. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  352. }
  353. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  354. // Try again, assuming key still not set. Only SubmitFrameMetadata()
  355. // should be called again.
  356. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(0);
  357. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _))
  358. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  359. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  360. // Assume key has been provided now, next call to Decode() should proceed.
  361. {
  362. InSequence sequence;
  363. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _));
  364. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _));
  365. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)));
  366. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0)));
  367. }
  368. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  369. EXPECT_TRUE(decoder_->Flush());
  370. }
  371. TEST_F(H265DecoderTest, SubmitSliceRetry) {
  372. SetInputFrameFiles({kSpsPps, kFrame0});
  373. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  374. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  375. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  376. EXPECT_EQ(8u, decoder_->GetBitDepth());
  377. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  378. {
  379. InSequence sequence;
  380. EXPECT_CALL(*accelerator_, CreateH265Picture());
  381. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _));
  382. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  383. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  384. }
  385. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  386. // Try again, assuming key still not set. Only SubmitSlice() should be
  387. // called again.
  388. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(0);
  389. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(0);
  390. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  391. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  392. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  393. // Assume key has been provided now, next call to Decode() should proceed.
  394. {
  395. InSequence sequence;
  396. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _));
  397. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)));
  398. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0)));
  399. }
  400. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  401. EXPECT_TRUE(decoder_->Flush());
  402. }
  403. TEST_F(H265DecoderTest, SubmitDecodeRetry) {
  404. SetInputFrameFiles({kSpsPps, kFrame0, kFrame1});
  405. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  406. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  407. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  408. EXPECT_EQ(8u, decoder_->GetBitDepth());
  409. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  410. {
  411. InSequence sequence;
  412. EXPECT_CALL(*accelerator_, CreateH265Picture());
  413. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _));
  414. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _));
  415. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)))
  416. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  417. }
  418. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  419. // Try again, assuming key still not set. Only SubmitDecode() should be
  420. // called again.
  421. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(0);
  422. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(0);
  423. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  424. .Times(0);
  425. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)))
  426. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain));
  427. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());
  428. // Assume key has been provided now, next call to Decode() should output
  429. // the first frame.
  430. {
  431. InSequence sequence;
  432. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0)));
  433. EXPECT_CALL(*accelerator_, CreateH265Picture());
  434. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _));
  435. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _));
  436. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(4)));
  437. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0)));
  438. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(4)));
  439. }
  440. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  441. EXPECT_TRUE(decoder_->Flush());
  442. }
  443. TEST_F(H265DecoderTest, SetStreamRetry) {
  444. SetInputFrameFiles({kSpsPps, kFrame0});
  445. EXPECT_CALL(*accelerator_, SetStream(_, _))
  446. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kTryAgain))
  447. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kOk))
  448. .WillOnce(Return(H265Decoder::H265Accelerator::Status::kOk));
  449. EXPECT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode(false));
  450. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode(false));
  451. EXPECT_EQ(gfx::Size(320, 184), decoder_->GetPicSize());
  452. EXPECT_EQ(HEVCPROFILE_MAIN, decoder_->GetProfile());
  453. EXPECT_EQ(8u, decoder_->GetBitDepth());
  454. EXPECT_EQ(17u, decoder_->GetRequiredNumOfPictures());
  455. {
  456. InSequence sequence;
  457. EXPECT_CALL(*accelerator_, CreateH265Picture()).Times(1);
  458. EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _)).Times(1);
  459. EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _, _, _, _, _))
  460. .Times(1);
  461. EXPECT_CALL(*accelerator_, SubmitDecode(HasPoc(0))).Times(1);
  462. EXPECT_CALL(*accelerator_, OutputPicture(HasPoc(0))).Times(1);
  463. }
  464. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode(false));
  465. EXPECT_TRUE(decoder_->Flush());
  466. }
  467. TEST_F(H265DecoderTest, DecodeMultiFrameInput) {
  468. SetInputFrameFiles({"bear.hevc"});
  469. EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());
  470. EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());
  471. EXPECT_TRUE(decoder_->Flush());
  472. }
  473. } // namespace media