vaapi_image_decode_accelerator_worker_unittest.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291
  1. // Copyright 2019 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 <stddef.h>
  5. #include <stdint.h>
  6. #include <va/va.h>
  7. #include <memory>
  8. #include <utility>
  9. #include <vector>
  10. #include "testing/gmock/include/gmock/gmock.h"
  11. #include "testing/gtest/include/gtest/gtest.h"
  12. #include "base/bind.h"
  13. #include "base/check_op.h"
  14. #include "base/containers/span.h"
  15. #include "base/memory/ptr_util.h"
  16. #include "base/memory/scoped_refptr.h"
  17. #include "base/notreached.h"
  18. #include "base/test/scoped_feature_list.h"
  19. #include "base/test/task_environment.h"
  20. #include "gpu/config/gpu_finch_features.h"
  21. #include "gpu/config/gpu_info.h"
  22. #include "gpu/ipc/service/image_decode_accelerator_worker.h"
  23. #include "media/gpu/vaapi/vaapi_image_decode_accelerator_worker.h"
  24. #include "media/gpu/vaapi/vaapi_image_decoder.h"
  25. #include "media/gpu/vaapi/vaapi_wrapper.h"
  26. #include "third_party/skia/include/core/SkImageInfo.h"
  27. #include "ui/gfx/buffer_types.h"
  28. #include "ui/gfx/geometry/size.h"
  29. #include "ui/gfx/linux/native_pixmap_dmabuf.h"
  30. #include "ui/gfx/native_pixmap_handle.h"
  31. using testing::_;
  32. using testing::AllOf;
  33. using testing::InSequence;
  34. using testing::IsNull;
  35. using testing::NotNull;
  36. using testing::Property;
  37. using testing::Return;
  38. using testing::StrictMock;
  39. namespace media {
  40. namespace {
  41. constexpr gfx::BufferFormat kFormatForDecodes = gfx::BufferFormat::YVU_420;
  42. constexpr gfx::Size kVaSurfaceResolution(128, 256);
  43. constexpr gfx::Size kVisibleSize(120, 250);
  44. constexpr size_t kWebPFileAndVp8ChunkHeaderSizeInBytes = 20u;
  45. // clang-format off
  46. constexpr uint8_t kJpegPFileHeader[] = {0xFF, 0xD8, 0xFF};
  47. constexpr uint8_t kLossyWebPFileHeader[] = {
  48. 'R', 'I', 'F', 'F',
  49. 0x0c, 0x00, 0x00, 0x00, // == 12 (little endian)
  50. 'W', 'E', 'B', 'P',
  51. 'V', 'P', '8', ' ',
  52. 0x00, 0x00, 0x00, 0x00 // == 0
  53. };
  54. // clang-format on
  55. constexpr base::span<const uint8_t, 3u> kJpegEncodedData = kJpegPFileHeader;
  56. constexpr base::span<const uint8_t, kWebPFileAndVp8ChunkHeaderSizeInBytes>
  57. kLossyWebPEncodedData = kLossyWebPFileHeader;
  58. class MockNativePixmapDmaBuf : public gfx::NativePixmapDmaBuf {
  59. public:
  60. MockNativePixmapDmaBuf(const gfx::Size& size)
  61. : gfx::NativePixmapDmaBuf(size,
  62. kFormatForDecodes,
  63. gfx::NativePixmapHandle()) {}
  64. gfx::NativePixmapHandle ExportHandle() override {
  65. gfx::NativePixmapHandle handle{};
  66. DCHECK_EQ(gfx::BufferFormat::YVU_420, GetBufferFormat());
  67. handle.planes = std::vector<gfx::NativePixmapPlane>(3u);
  68. return handle;
  69. }
  70. protected:
  71. ~MockNativePixmapDmaBuf() override = default;
  72. };
  73. class MockVaapiImageDecoder : public VaapiImageDecoder {
  74. public:
  75. MockVaapiImageDecoder(gpu::ImageDecodeAcceleratorType type)
  76. : VaapiImageDecoder(VAProfileNone), type_(type) {}
  77. ~MockVaapiImageDecoder() override = default;
  78. gpu::ImageDecodeAcceleratorType GetType() const override { return type_; }
  79. SkYUVColorSpace GetYUVColorSpace() const override {
  80. switch (type_) {
  81. case gpu::ImageDecodeAcceleratorType::kJpeg:
  82. return SkYUVColorSpace::kJPEG_SkYUVColorSpace;
  83. case gpu::ImageDecodeAcceleratorType::kWebP:
  84. return SkYUVColorSpace::kRec601_SkYUVColorSpace;
  85. case gpu::ImageDecodeAcceleratorType::kUnknown:
  86. NOTREACHED();
  87. return SkYUVColorSpace::kIdentity_SkYUVColorSpace;
  88. }
  89. }
  90. gpu::ImageDecodeAcceleratorSupportedProfile GetSupportedProfile()
  91. const override {
  92. return gpu::ImageDecodeAcceleratorSupportedProfile();
  93. }
  94. MOCK_METHOD1(Initialize, bool(const ReportErrorToUMACB&));
  95. MOCK_METHOD1(Decode, VaapiImageDecodeStatus(base::span<const uint8_t>));
  96. MOCK_CONST_METHOD0(GetScopedVASurface, const ScopedVASurface*());
  97. MOCK_METHOD1(
  98. ExportAsNativePixmapDmaBuf,
  99. std::unique_ptr<NativePixmapAndSizeInfo>(VaapiImageDecodeStatus*));
  100. MOCK_METHOD1(AllocateVASurfaceAndSubmitVABuffers,
  101. VaapiImageDecodeStatus(base::span<const uint8_t>));
  102. private:
  103. const gpu::ImageDecodeAcceleratorType type_;
  104. };
  105. } // namespace
  106. class VaapiImageDecodeAcceleratorWorkerTest : public testing::Test {
  107. public:
  108. VaapiImageDecodeAcceleratorWorkerTest() {
  109. feature_list_.InitWithFeatures(
  110. {features::kVaapiJpegImageDecodeAcceleration,
  111. features::kVaapiWebPImageDecodeAcceleration} /* enabled_features */,
  112. {} /* disabled_features */);
  113. VaapiImageDecoderVector decoders;
  114. decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
  115. gpu::ImageDecodeAcceleratorType::kJpeg));
  116. decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
  117. gpu::ImageDecodeAcceleratorType::kWebP));
  118. worker_ = base::WrapUnique(
  119. new VaapiImageDecodeAcceleratorWorker(std::move(decoders)));
  120. }
  121. VaapiImageDecodeAcceleratorWorkerTest(
  122. const VaapiImageDecodeAcceleratorWorkerTest&) = delete;
  123. VaapiImageDecodeAcceleratorWorkerTest& operator=(
  124. const VaapiImageDecodeAcceleratorWorkerTest&) = delete;
  125. MockVaapiImageDecoder* GetJpegDecoder() const {
  126. auto result =
  127. worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kJpeg);
  128. return result == worker_->decoders_.end()
  129. ? nullptr
  130. : static_cast<MockVaapiImageDecoder*>(result->second.get());
  131. }
  132. MockVaapiImageDecoder* GetWebPDecoder() const {
  133. auto result =
  134. worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kWebP);
  135. return result == worker_->decoders_.end()
  136. ? nullptr
  137. : static_cast<MockVaapiImageDecoder*>(result->second.get());
  138. }
  139. MOCK_METHOD1(
  140. OnDecodeCompleted,
  141. void(std::unique_ptr<gpu::ImageDecodeAcceleratorWorker::DecodeResult>));
  142. protected:
  143. base::test::TaskEnvironment task_environment_;
  144. base::test::ScopedFeatureList feature_list_;
  145. std::unique_ptr<VaapiImageDecodeAcceleratorWorker> worker_;
  146. };
  147. ACTION_P2(ExportAsNativePixmapDmaBufSuccessfully,
  148. va_surface_resolution,
  149. visible_size) {
  150. *arg0 = VaapiImageDecodeStatus::kSuccess;
  151. auto exported_pixmap = std::make_unique<NativePixmapAndSizeInfo>();
  152. exported_pixmap->va_surface_resolution = va_surface_resolution;
  153. exported_pixmap->byte_size = 1u;
  154. exported_pixmap->pixmap =
  155. base::MakeRefCounted<MockNativePixmapDmaBuf>(visible_size);
  156. return exported_pixmap;
  157. }
  158. TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeSucceeds) {
  159. std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
  160. kJpegEncodedData.end());
  161. std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
  162. kLossyWebPEncodedData.end());
  163. {
  164. InSequence sequence;
  165. MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
  166. ASSERT_TRUE(jpeg_decoder);
  167. EXPECT_CALL(
  168. *jpeg_decoder,
  169. Decode(AllOf(Property(&base::span<const uint8_t>::data,
  170. jpeg_encoded_data.data()),
  171. Property(&base::span<const uint8_t>::size,
  172. jpeg_encoded_data.size())) /* encoded_data */))
  173. .WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
  174. EXPECT_CALL(*jpeg_decoder,
  175. ExportAsNativePixmapDmaBuf(NotNull() /* status */))
  176. .WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
  177. kVisibleSize));
  178. EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));
  179. MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
  180. ASSERT_TRUE(webp_decoder);
  181. EXPECT_CALL(
  182. *webp_decoder,
  183. Decode(AllOf(Property(&base::span<const uint8_t>::data,
  184. webp_encoded_data.data()),
  185. Property(&base::span<const uint8_t>::size,
  186. webp_encoded_data.size())) /* encoded_data */))
  187. .WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
  188. EXPECT_CALL(*webp_decoder,
  189. ExportAsNativePixmapDmaBuf(NotNull() /* status */))
  190. .WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
  191. kVisibleSize));
  192. EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));
  193. }
  194. worker_->Decode(
  195. std::move(jpeg_encoded_data), kVisibleSize,
  196. base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
  197. base::Unretained(this)));
  198. worker_->Decode(
  199. std::move(webp_encoded_data), kVisibleSize,
  200. base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
  201. base::Unretained(this)));
  202. task_environment_.RunUntilIdle();
  203. }
  204. TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeFails) {
  205. std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
  206. kJpegEncodedData.end());
  207. std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
  208. kLossyWebPEncodedData.end());
  209. {
  210. InSequence sequence;
  211. MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
  212. ASSERT_TRUE(jpeg_decoder);
  213. EXPECT_CALL(
  214. *jpeg_decoder,
  215. Decode(AllOf(Property(&base::span<const uint8_t>::data,
  216. jpeg_encoded_data.data()),
  217. Property(&base::span<const uint8_t>::size,
  218. jpeg_encoded_data.size())) /* encoded_data */))
  219. .WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
  220. EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
  221. MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
  222. ASSERT_TRUE(webp_decoder);
  223. EXPECT_CALL(
  224. *webp_decoder,
  225. Decode(AllOf(Property(&base::span<const uint8_t>::data,
  226. webp_encoded_data.data()),
  227. Property(&base::span<const uint8_t>::size,
  228. webp_encoded_data.size())) /* encoded_data */))
  229. .WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
  230. EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
  231. }
  232. worker_->Decode(
  233. std::move(jpeg_encoded_data), kVisibleSize,
  234. base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
  235. base::Unretained(this)));
  236. worker_->Decode(
  237. std::move(webp_encoded_data), kVisibleSize,
  238. base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
  239. base::Unretained(this)));
  240. task_environment_.RunUntilIdle();
  241. }
  242. TEST_F(VaapiImageDecodeAcceleratorWorkerTest, UnknownImageDecodeFails) {
  243. std::vector<uint8_t> encoded_data = {1u, 2u, 3u};
  244. EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
  245. worker_->Decode(
  246. std::move(encoded_data), kVisibleSize,
  247. base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
  248. base::Unretained(this)));
  249. task_environment_.RunUntilIdle();
  250. }
  251. } // namespace media