VkHardwareBufferTest.cpp 49 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315
  1. /*
  2. * Copyright 2018 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. // This is a GPU-backend specific test. It relies on static intializers to work
  8. #include "include/core/SkTypes.h"
  9. #if SK_SUPPORT_GPU && defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26 && defined(SK_VULKAN)
  10. #include "include/core/SkCanvas.h"
  11. #include "include/core/SkImage.h"
  12. #include "include/core/SkSurface.h"
  13. #include "include/gpu/GrBackendSemaphore.h"
  14. #include "include/gpu/GrContext.h"
  15. #include "include/gpu/vk/GrVkBackendContext.h"
  16. #include "include/gpu/vk/GrVkExtensions.h"
  17. #include "src/core/SkAutoMalloc.h"
  18. #include "src/gpu/GrContextPriv.h"
  19. #include "src/gpu/GrGpu.h"
  20. #include "src/gpu/GrProxyProvider.h"
  21. #include "src/gpu/SkGr.h"
  22. #include "src/gpu/gl/GrGLDefines.h"
  23. #include "src/gpu/gl/GrGLUtil.h"
  24. #include "tests/Test.h"
  25. #include "tools/gpu/GrContextFactory.h"
  26. #include "tools/gpu/vk/VkTestUtils.h"
  27. #include <android/hardware_buffer.h>
  28. #include <cinttypes>
  29. #include <EGL/egl.h>
  30. #include <EGL/eglext.h>
  31. #include <GLES/gl.h>
  32. #include <GLES/glext.h>
  33. static const int DEV_W = 16, DEV_H = 16;
  34. class BaseTestHelper {
  35. public:
  36. virtual ~BaseTestHelper() {}
  37. virtual bool init(skiatest::Reporter* reporter) = 0;
  38. virtual void cleanup() = 0;
  39. virtual void releaseImage() = 0;
  40. virtual sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
  41. AHardwareBuffer* buffer) = 0;
  42. virtual sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
  43. AHardwareBuffer* buffer) = 0;
  44. virtual void doClientSync() = 0;
  45. virtual bool flushSurfaceAndSignalSemaphore(skiatest::Reporter* reporter, sk_sp<SkSurface>) = 0;
  46. virtual bool importAndWaitOnSemaphore(skiatest::Reporter* reporter, int fdHandle,
  47. sk_sp<SkSurface>) = 0;
  48. virtual void makeCurrent() = 0;
  49. virtual GrContext* grContext() = 0;
  50. int getFdHandle() { return fFdHandle; }
  51. protected:
  52. BaseTestHelper() {}
  53. int fFdHandle = 0;
  54. };
  55. class EGLTestHelper : public BaseTestHelper {
  56. public:
  57. EGLTestHelper(const GrContextOptions& options) : fFactory(options) {}
  58. ~EGLTestHelper() override {}
  59. void releaseImage() override {
  60. this->makeCurrent();
  61. if (!fGLCtx) {
  62. return;
  63. }
  64. if (EGL_NO_IMAGE_KHR != fImage) {
  65. fGLCtx->destroyEGLImage(fImage);
  66. fImage = EGL_NO_IMAGE_KHR;
  67. }
  68. if (fTexID) {
  69. GR_GL_CALL(fGLCtx->gl(), DeleteTextures(1, &fTexID));
  70. fTexID = 0;
  71. }
  72. }
  73. void cleanup() override {
  74. this->releaseImage();
  75. }
  76. bool init(skiatest::Reporter* reporter) override;
  77. sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
  78. AHardwareBuffer* buffer) override;
  79. sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
  80. AHardwareBuffer* buffer) override;
  81. void doClientSync() override;
  82. bool flushSurfaceAndSignalSemaphore(skiatest::Reporter* reporter, sk_sp<SkSurface>) override;
  83. bool importAndWaitOnSemaphore(skiatest::Reporter* reporter, int fdHandle,
  84. sk_sp<SkSurface>) override;
  85. void makeCurrent() override { fGLCtx->makeCurrent(); }
  86. GrContext* grContext() override { return fGrContext; }
  87. private:
  88. bool importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer);
  89. typedef EGLClientBuffer (*EGLGetNativeClientBufferANDROIDProc)(const struct AHardwareBuffer*);
  90. typedef EGLImageKHR (*EGLCreateImageKHRProc)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer,
  91. const EGLint*);
  92. typedef void (*EGLImageTargetTexture2DOESProc)(EGLenum, void*);
  93. EGLGetNativeClientBufferANDROIDProc fEGLGetNativeClientBufferANDROID;
  94. EGLCreateImageKHRProc fEGLCreateImageKHR;
  95. EGLImageTargetTexture2DOESProc fEGLImageTargetTexture2DOES;
  96. PFNEGLCREATESYNCKHRPROC fEGLCreateSyncKHR;
  97. PFNEGLWAITSYNCKHRPROC fEGLWaitSyncKHR;
  98. PFNEGLGETSYNCATTRIBKHRPROC fEGLGetSyncAttribKHR;
  99. PFNEGLDUPNATIVEFENCEFDANDROIDPROC fEGLDupNativeFenceFDANDROID;
  100. PFNEGLDESTROYSYNCKHRPROC fEGLDestroySyncKHR;
  101. EGLImageKHR fImage = EGL_NO_IMAGE_KHR;
  102. GrGLuint fTexID = 0;
  103. sk_gpu_test::GrContextFactory fFactory;
  104. sk_gpu_test::ContextInfo fGLESContextInfo;
  105. sk_gpu_test::GLTestContext* fGLCtx = nullptr;
  106. GrContext* fGrContext = nullptr;
  107. };
  108. bool EGLTestHelper::init(skiatest::Reporter* reporter) {
  109. fGLESContextInfo = fFactory.getContextInfo(sk_gpu_test::GrContextFactory::kGLES_ContextType);
  110. fGrContext = fGLESContextInfo.grContext();
  111. fGLCtx = fGLESContextInfo.glContext();
  112. if (!fGrContext || !fGLCtx) {
  113. return false;
  114. }
  115. if (kGLES_GrGLStandard != fGLCtx->gl()->fStandard) {
  116. return false;
  117. }
  118. // Confirm we have egl and the needed extensions
  119. if (!fGLCtx->gl()->hasExtension("EGL_KHR_image") ||
  120. !fGLCtx->gl()->hasExtension("EGL_ANDROID_get_native_client_buffer") ||
  121. !fGLCtx->gl()->hasExtension("GL_OES_EGL_image_external") ||
  122. !fGLCtx->gl()->hasExtension("GL_OES_EGL_image") ||
  123. !fGLCtx->gl()->hasExtension("EGL_KHR_fence_sync") ||
  124. !fGLCtx->gl()->hasExtension("EGL_ANDROID_native_fence_sync")) {
  125. return false;
  126. }
  127. fEGLGetNativeClientBufferANDROID =
  128. (EGLGetNativeClientBufferANDROIDProc) eglGetProcAddress("eglGetNativeClientBufferANDROID");
  129. if (!fEGLGetNativeClientBufferANDROID) {
  130. ERRORF(reporter, "Failed to get the eglGetNativeClientBufferAndroid proc");
  131. return false;
  132. }
  133. fEGLCreateImageKHR = (EGLCreateImageKHRProc) eglGetProcAddress("eglCreateImageKHR");
  134. if (!fEGLCreateImageKHR) {
  135. ERRORF(reporter, "Failed to get the proc eglCreateImageKHR");
  136. return false;
  137. }
  138. fEGLImageTargetTexture2DOES =
  139. (EGLImageTargetTexture2DOESProc) eglGetProcAddress("glEGLImageTargetTexture2DOES");
  140. if (!fEGLImageTargetTexture2DOES) {
  141. ERRORF(reporter, "Failed to get the proc EGLImageTargetTexture2DOES");
  142. return false;
  143. }
  144. fEGLCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC) eglGetProcAddress("eglCreateSyncKHR");
  145. if (!fEGLCreateSyncKHR) {
  146. ERRORF(reporter, "Failed to get the proc eglCreateSyncKHR");
  147. return false;
  148. }
  149. fEGLWaitSyncKHR = (PFNEGLWAITSYNCKHRPROC) eglGetProcAddress("eglWaitSyncKHR");
  150. if (!fEGLWaitSyncKHR) {
  151. ERRORF(reporter, "Failed to get the proc eglWaitSyncKHR");
  152. return false;
  153. }
  154. fEGLGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC) eglGetProcAddress("eglGetSyncAttribKHR");
  155. if (!fEGLGetSyncAttribKHR) {
  156. ERRORF(reporter, "Failed to get the proc eglGetSyncAttribKHR");
  157. return false;
  158. }
  159. fEGLDupNativeFenceFDANDROID =
  160. (PFNEGLDUPNATIVEFENCEFDANDROIDPROC) eglGetProcAddress("eglDupNativeFenceFDANDROID");
  161. if (!fEGLDupNativeFenceFDANDROID) {
  162. ERRORF(reporter, "Failed to get the proc eglDupNativeFenceFDANDROID");
  163. return false;
  164. }
  165. fEGLDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC) eglGetProcAddress("eglDestroySyncKHR");
  166. if (!fEGLDestroySyncKHR) {
  167. ERRORF(reporter, "Failed to get the proc eglDestroySyncKHR");
  168. return false;
  169. }
  170. return true;
  171. }
  172. bool EGLTestHelper::importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer) {
  173. GrGLClearErr(fGLCtx->gl());
  174. EGLClientBuffer eglClientBuffer = fEGLGetNativeClientBufferANDROID(buffer);
  175. EGLint eglAttribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
  176. EGL_NONE };
  177. EGLDisplay eglDisplay = eglGetCurrentDisplay();
  178. fImage = fEGLCreateImageKHR(eglDisplay, EGL_NO_CONTEXT,
  179. EGL_NATIVE_BUFFER_ANDROID,
  180. eglClientBuffer, eglAttribs);
  181. if (EGL_NO_IMAGE_KHR == fImage) {
  182. SkDebugf("Could not create EGL image, err = (%#x)\n", (int) eglGetError() );
  183. return false;
  184. }
  185. GR_GL_CALL(fGLCtx->gl(), GenTextures(1, &fTexID));
  186. if (!fTexID) {
  187. ERRORF(reporter, "Failed to create GL Texture");
  188. return false;
  189. }
  190. GR_GL_CALL_NOERRCHECK(fGLCtx->gl(), BindTexture(GR_GL_TEXTURE_2D, fTexID));
  191. if (GR_GL_GET_ERROR(fGLCtx->gl()) != GR_GL_NO_ERROR) {
  192. ERRORF(reporter, "Failed to bind GL Texture");
  193. return false;
  194. }
  195. fEGLImageTargetTexture2DOES(GL_TEXTURE_2D, fImage);
  196. GLenum status = GL_NO_ERROR;
  197. if ((status = glGetError()) != GL_NO_ERROR) {
  198. ERRORF(reporter, "EGLImageTargetTexture2DOES failed (%#x)", (int) status);
  199. return false;
  200. }
  201. fGrContext->resetContext(kTextureBinding_GrGLBackendState);
  202. return true;
  203. }
  204. sk_sp<SkImage> EGLTestHelper::importHardwareBufferForRead(skiatest::Reporter* reporter,
  205. AHardwareBuffer* buffer) {
  206. if (!this->importHardwareBuffer(reporter, buffer)) {
  207. return nullptr;
  208. }
  209. GrGLTextureInfo textureInfo;
  210. textureInfo.fTarget = GR_GL_TEXTURE_2D;
  211. textureInfo.fID = fTexID;
  212. textureInfo.fFormat = GR_GL_RGBA8;
  213. GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
  214. REPORTER_ASSERT(reporter, backendTex.isValid());
  215. sk_sp<SkImage> image = SkImage::MakeFromTexture(fGrContext,
  216. backendTex,
  217. kTopLeft_GrSurfaceOrigin,
  218. kRGBA_8888_SkColorType,
  219. kPremul_SkAlphaType,
  220. nullptr);
  221. if (!image) {
  222. ERRORF(reporter, "Failed to make wrapped GL SkImage");
  223. return nullptr;
  224. }
  225. return image;
  226. }
  227. sk_sp<SkSurface> EGLTestHelper::importHardwareBufferForWrite(skiatest::Reporter* reporter,
  228. AHardwareBuffer* buffer) {
  229. if (!this->importHardwareBuffer(reporter, buffer)) {
  230. return nullptr;
  231. }
  232. GrGLTextureInfo textureInfo;
  233. textureInfo.fTarget = GR_GL_TEXTURE_2D;
  234. textureInfo.fID = fTexID;
  235. textureInfo.fFormat = GR_GL_RGBA8;
  236. GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
  237. REPORTER_ASSERT(reporter, backendTex.isValid());
  238. sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(fGrContext,
  239. backendTex,
  240. kTopLeft_GrSurfaceOrigin,
  241. 0,
  242. kRGBA_8888_SkColorType,
  243. nullptr, nullptr);
  244. if (!surface) {
  245. ERRORF(reporter, "Failed to make wrapped GL SkSurface");
  246. return nullptr;
  247. }
  248. return surface;
  249. }
  250. bool EGLTestHelper::flushSurfaceAndSignalSemaphore(skiatest::Reporter* reporter,
  251. sk_sp<SkSurface> surface) {
  252. EGLDisplay eglDisplay = eglGetCurrentDisplay();
  253. EGLSyncKHR eglsync = fEGLCreateSyncKHR(eglDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
  254. if (EGL_NO_SYNC_KHR == eglsync) {
  255. ERRORF(reporter, "Failed to create EGLSync for EGL_SYNC_NATIVE_FENCE_ANDROID\n");
  256. return false;
  257. }
  258. surface->flush();
  259. GR_GL_CALL(fGLCtx->gl(), Flush());
  260. fFdHandle = fEGLDupNativeFenceFDANDROID(eglDisplay, eglsync);
  261. EGLint result = fEGLDestroySyncKHR(eglDisplay, eglsync);
  262. if (EGL_TRUE != result) {
  263. ERRORF(reporter, "Failed to delete EGLSync, error: %d\n", result);
  264. return false;
  265. }
  266. return true;
  267. }
  268. bool EGLTestHelper::importAndWaitOnSemaphore(skiatest::Reporter* reporter, int fdHandle,
  269. sk_sp<SkSurface> surface) {
  270. EGLDisplay eglDisplay = eglGetCurrentDisplay();
  271. EGLint attr[] = {
  272. EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fdHandle,
  273. EGL_NONE
  274. };
  275. EGLSyncKHR eglsync = fEGLCreateSyncKHR(eglDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attr);
  276. if (EGL_NO_SYNC_KHR == eglsync) {
  277. ERRORF(reporter,
  278. "Failed to create EGLSync when importing EGL_SYNC_NATIVE_FENCE_FD_ANDROID\n");
  279. return false;
  280. }
  281. EGLint result = fEGLWaitSyncKHR(eglDisplay, eglsync, 0);
  282. if (EGL_TRUE != result) {
  283. ERRORF(reporter, "Failed called to eglWaitSyncKHR, error: %d\n", result);
  284. // Don't return false yet, try to delete the sync first
  285. }
  286. result = fEGLDestroySyncKHR(eglDisplay, eglsync);
  287. if (EGL_TRUE != result) {
  288. ERRORF(reporter, "Failed to delete EGLSync, error: %d\n", result);
  289. return false;
  290. }
  291. return true;
  292. }
  293. void EGLTestHelper::doClientSync() {
  294. sk_gpu_test::FenceSync* fenceSync = fGLCtx->fenceSync();
  295. sk_gpu_test::PlatformFence fence = fenceSync->insertFence();
  296. fenceSync->waitFence(fence);
  297. fenceSync->deleteFence(fence);
  298. }
  299. #define DECLARE_VK_PROC(name) PFN_vk##name fVk##name
  300. #define ACQUIRE_INST_VK_PROC(name) \
  301. fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, fBackendContext.fInstance,\
  302. VK_NULL_HANDLE)); \
  303. if (fVk##name == nullptr) { \
  304. ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name); \
  305. return false; \
  306. }
  307. #define ACQUIRE_DEVICE_VK_PROC(name) \
  308. fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, VK_NULL_HANDLE, fDevice)); \
  309. if (fVk##name == nullptr) { \
  310. ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name); \
  311. return false; \
  312. }
  313. class VulkanTestHelper : public BaseTestHelper {
  314. public:
  315. VulkanTestHelper() {}
  316. ~VulkanTestHelper() override {}
  317. void releaseImage() override {
  318. if (VK_NULL_HANDLE == fDevice) {
  319. return;
  320. }
  321. if (fImage != VK_NULL_HANDLE) {
  322. fVkDestroyImage(fDevice, fImage, nullptr);
  323. fImage = VK_NULL_HANDLE;
  324. }
  325. if (fMemory != VK_NULL_HANDLE) {
  326. fVkFreeMemory(fDevice, fMemory, nullptr);
  327. fMemory = VK_NULL_HANDLE;
  328. }
  329. }
  330. void cleanup() override {
  331. fGrContext.reset();
  332. this->releaseImage();
  333. if (fSignalSemaphore != VK_NULL_HANDLE) {
  334. fVkDestroySemaphore(fDevice, fSignalSemaphore, nullptr);
  335. fSignalSemaphore = VK_NULL_HANDLE;
  336. }
  337. fBackendContext.fMemoryAllocator.reset();
  338. if (fDevice != VK_NULL_HANDLE) {
  339. fVkDeviceWaitIdle(fDevice);
  340. fVkDestroyDevice(fDevice, nullptr);
  341. fDevice = VK_NULL_HANDLE;
  342. }
  343. #ifdef SK_ENABLE_VK_LAYERS
  344. if (fDebugCallback != VK_NULL_HANDLE) {
  345. fDestroyDebugCallback(fBackendContext.fInstance, fDebugCallback, nullptr);
  346. }
  347. #endif
  348. if (fBackendContext.fInstance != VK_NULL_HANDLE) {
  349. fVkDestroyInstance(fBackendContext.fInstance, nullptr);
  350. fBackendContext.fInstance = VK_NULL_HANDLE;
  351. }
  352. delete fExtensions;
  353. sk_gpu_test::FreeVulkanFeaturesStructs(fFeatures);
  354. delete fFeatures;
  355. }
  356. bool init(skiatest::Reporter* reporter) override;
  357. void doClientSync() override {
  358. if (!fGrContext) {
  359. return;
  360. }
  361. fGrContext->priv().getGpu()->testingOnly_flushGpuAndSync();
  362. }
  363. bool flushSurfaceAndSignalSemaphore(skiatest::Reporter* reporter, sk_sp<SkSurface>) override;
  364. bool importAndWaitOnSemaphore(skiatest::Reporter* reporter, int fdHandle,
  365. sk_sp<SkSurface>) override;
  366. sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
  367. AHardwareBuffer* buffer) override;
  368. sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
  369. AHardwareBuffer* buffer) override;
  370. void makeCurrent() override {}
  371. GrContext* grContext() override { return fGrContext.get(); }
  372. private:
  373. bool checkOptimalHardwareBuffer(skiatest::Reporter* reporter);
  374. bool importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer, bool forWrite,
  375. GrVkImageInfo* outImageInfo);
  376. bool setupSemaphoreForSignaling(skiatest::Reporter* reporter, GrBackendSemaphore*);
  377. bool exportSemaphore(skiatest::Reporter* reporter, const GrBackendSemaphore&);
  378. DECLARE_VK_PROC(DestroyInstance);
  379. DECLARE_VK_PROC(DeviceWaitIdle);
  380. DECLARE_VK_PROC(DestroyDevice);
  381. DECLARE_VK_PROC(GetPhysicalDeviceExternalSemaphoreProperties);
  382. DECLARE_VK_PROC(GetPhysicalDeviceImageFormatProperties2);
  383. DECLARE_VK_PROC(GetPhysicalDeviceMemoryProperties2);
  384. DECLARE_VK_PROC(GetAndroidHardwareBufferPropertiesANDROID);
  385. DECLARE_VK_PROC(CreateImage);
  386. DECLARE_VK_PROC(GetImageMemoryRequirements2);
  387. DECLARE_VK_PROC(DestroyImage);
  388. DECLARE_VK_PROC(AllocateMemory);
  389. DECLARE_VK_PROC(BindImageMemory2);
  390. DECLARE_VK_PROC(FreeMemory);
  391. DECLARE_VK_PROC(CreateSemaphore);
  392. DECLARE_VK_PROC(GetSemaphoreFdKHR);
  393. DECLARE_VK_PROC(ImportSemaphoreFdKHR);
  394. DECLARE_VK_PROC(DestroySemaphore);
  395. VkImage fImage = VK_NULL_HANDLE;
  396. VkDeviceMemory fMemory = VK_NULL_HANDLE;
  397. GrVkExtensions* fExtensions = nullptr;
  398. VkPhysicalDeviceFeatures2* fFeatures = nullptr;
  399. VkDebugReportCallbackEXT fDebugCallback = VK_NULL_HANDLE;
  400. PFN_vkDestroyDebugReportCallbackEXT fDestroyDebugCallback = nullptr;
  401. // We hold on to the semaphore so we can delete once the GPU is done.
  402. VkSemaphore fSignalSemaphore = VK_NULL_HANDLE;
  403. VkDevice fDevice = VK_NULL_HANDLE;
  404. GrVkBackendContext fBackendContext;
  405. sk_sp<GrContext> fGrContext;
  406. };
  407. bool VulkanTestHelper::init(skiatest::Reporter* reporter) {
  408. PFN_vkGetInstanceProcAddr instProc;
  409. PFN_vkGetDeviceProcAddr devProc;
  410. if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
  411. return false;
  412. }
  413. auto getProc = [&instProc, &devProc](const char* proc_name,
  414. VkInstance instance, VkDevice device) {
  415. if (device != VK_NULL_HANDLE) {
  416. return devProc(device, proc_name);
  417. }
  418. return instProc(instance, proc_name);
  419. };
  420. fExtensions = new GrVkExtensions();
  421. fFeatures = new VkPhysicalDeviceFeatures2;
  422. memset(fFeatures, 0, sizeof(VkPhysicalDeviceFeatures2));
  423. fFeatures->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
  424. fFeatures->pNext = nullptr;
  425. fBackendContext.fInstance = VK_NULL_HANDLE;
  426. fBackendContext.fDevice = VK_NULL_HANDLE;
  427. if (!sk_gpu_test::CreateVkBackendContext(getProc, &fBackendContext, fExtensions,
  428. fFeatures, &fDebugCallback)) {
  429. return false;
  430. }
  431. fDevice = fBackendContext.fDevice;
  432. if (fDebugCallback != VK_NULL_HANDLE) {
  433. fDestroyDebugCallback = (PFN_vkDestroyDebugReportCallbackEXT) instProc(
  434. fBackendContext.fInstance, "vkDestroyDebugReportCallbackEXT");
  435. }
  436. ACQUIRE_INST_VK_PROC(DestroyInstance);
  437. ACQUIRE_INST_VK_PROC(DeviceWaitIdle);
  438. ACQUIRE_INST_VK_PROC(DestroyDevice);
  439. if (!fExtensions->hasExtension(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
  440. 2)) {
  441. return false;
  442. }
  443. if (!fExtensions->hasExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, 1)) {
  444. return false;
  445. }
  446. if (!fExtensions->hasExtension(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1)) {
  447. return false;
  448. }
  449. if (!fExtensions->hasExtension(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1)) {
  450. // return false;
  451. }
  452. ACQUIRE_INST_VK_PROC(GetPhysicalDeviceMemoryProperties2);
  453. ACQUIRE_INST_VK_PROC(GetPhysicalDeviceImageFormatProperties2);
  454. ACQUIRE_INST_VK_PROC(GetPhysicalDeviceExternalSemaphoreProperties);
  455. ACQUIRE_DEVICE_VK_PROC(GetAndroidHardwareBufferPropertiesANDROID);
  456. ACQUIRE_DEVICE_VK_PROC(CreateImage);
  457. ACQUIRE_DEVICE_VK_PROC(GetImageMemoryRequirements2);
  458. ACQUIRE_DEVICE_VK_PROC(DestroyImage);
  459. ACQUIRE_DEVICE_VK_PROC(AllocateMemory);
  460. ACQUIRE_DEVICE_VK_PROC(BindImageMemory2);
  461. ACQUIRE_DEVICE_VK_PROC(FreeMemory);
  462. ACQUIRE_DEVICE_VK_PROC(CreateSemaphore);
  463. ACQUIRE_DEVICE_VK_PROC(GetSemaphoreFdKHR);
  464. ACQUIRE_DEVICE_VK_PROC(ImportSemaphoreFdKHR);
  465. ACQUIRE_DEVICE_VK_PROC(DestroySemaphore);
  466. fGrContext = GrContext::MakeVulkan(fBackendContext);
  467. REPORTER_ASSERT(reporter, fGrContext.get());
  468. if (!fGrContext) {
  469. return false;
  470. }
  471. return this->checkOptimalHardwareBuffer(reporter);
  472. }
  473. bool VulkanTestHelper::checkOptimalHardwareBuffer(skiatest::Reporter* reporter) {
  474. VkResult err;
  475. VkPhysicalDeviceExternalImageFormatInfo externalImageFormatInfo;
  476. externalImageFormatInfo.sType =
  477. VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
  478. externalImageFormatInfo.pNext = nullptr;
  479. externalImageFormatInfo.handleType =
  480. VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
  481. //externalImageFormatInfo.handType = 0x80;
  482. // We will create the hardware buffer with gpu sampled so these usages should all be valid
  483. VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT |
  484. VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
  485. VK_IMAGE_USAGE_TRANSFER_DST_BIT;
  486. VkPhysicalDeviceImageFormatInfo2 imageFormatInfo;
  487. imageFormatInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
  488. imageFormatInfo.pNext = &externalImageFormatInfo;
  489. imageFormatInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
  490. imageFormatInfo.type = VK_IMAGE_TYPE_2D;
  491. imageFormatInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
  492. imageFormatInfo.usage = usageFlags;
  493. imageFormatInfo.flags = 0;
  494. VkAndroidHardwareBufferUsageANDROID hwbUsage;
  495. hwbUsage.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID;
  496. hwbUsage.pNext = nullptr;
  497. VkExternalImageFormatProperties externalImgFormatProps;
  498. externalImgFormatProps.sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
  499. externalImgFormatProps.pNext = &hwbUsage;
  500. VkImageFormatProperties2 imgFormProps;
  501. imgFormProps.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
  502. imgFormProps.pNext = &externalImgFormatProps;
  503. err = fVkGetPhysicalDeviceImageFormatProperties2(fBackendContext.fPhysicalDevice,
  504. &imageFormatInfo, &imgFormProps);
  505. if (VK_SUCCESS != err) {
  506. ERRORF(reporter, "vkGetPhysicalDeviceImageFormatProperites failed, err: %d", err);
  507. return false;
  508. }
  509. const VkImageFormatProperties& imageFormatProperties = imgFormProps.imageFormatProperties;
  510. REPORTER_ASSERT(reporter, DEV_W <= imageFormatProperties.maxExtent.width);
  511. REPORTER_ASSERT(reporter, DEV_H <= imageFormatProperties.maxExtent.height);
  512. const VkExternalMemoryProperties& externalImageFormatProps =
  513. externalImgFormatProps.externalMemoryProperties;
  514. REPORTER_ASSERT(reporter, SkToBool(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT &
  515. externalImageFormatProps.externalMemoryFeatures));
  516. REPORTER_ASSERT(reporter, SkToBool(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT &
  517. externalImageFormatProps.externalMemoryFeatures));
  518. REPORTER_ASSERT(reporter, SkToBool(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE &
  519. hwbUsage.androidHardwareBufferUsage));
  520. return true;
  521. }
  522. bool VulkanTestHelper::importHardwareBuffer(skiatest::Reporter* reporter,
  523. AHardwareBuffer* buffer,
  524. bool forWrite,
  525. GrVkImageInfo* outImageInfo) {
  526. VkResult err;
  527. VkAndroidHardwareBufferFormatPropertiesANDROID hwbFormatProps;
  528. hwbFormatProps.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
  529. hwbFormatProps.pNext = nullptr;
  530. VkAndroidHardwareBufferPropertiesANDROID hwbProps;
  531. hwbProps.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
  532. hwbProps.pNext = &hwbFormatProps;
  533. err = fVkGetAndroidHardwareBufferPropertiesANDROID(fDevice, buffer, &hwbProps);
  534. if (VK_SUCCESS != err) {
  535. ERRORF(reporter, "GetAndroidHardwareBufferPropertiesAndroid failed, err: %d", err);
  536. return false;
  537. }
  538. REPORTER_ASSERT(reporter, VK_FORMAT_R8G8B8A8_UNORM == hwbFormatProps.format);
  539. REPORTER_ASSERT(reporter,
  540. SkToBool(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & hwbFormatProps.formatFeatures) &&
  541. SkToBool(VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & hwbFormatProps.formatFeatures) &&
  542. SkToBool(VK_FORMAT_FEATURE_TRANSFER_DST_BIT & hwbFormatProps.formatFeatures));
  543. if (forWrite) {
  544. REPORTER_ASSERT(reporter,
  545. SkToBool(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & hwbFormatProps.formatFeatures));
  546. }
  547. bool useExternalFormat = VK_FORMAT_UNDEFINED == hwbFormatProps.format;
  548. const VkExternalFormatANDROID externalFormatInfo {
  549. VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, // sType
  550. nullptr, // pNext
  551. useExternalFormat ? hwbFormatProps.externalFormat : 0, // externalFormat
  552. };
  553. const VkExternalMemoryImageCreateInfo externalMemoryImageInfo {
  554. VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, // sType
  555. &externalFormatInfo, // pNext
  556. VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, // handleTypes
  557. };
  558. VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT |
  559. VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
  560. VK_IMAGE_USAGE_TRANSFER_DST_BIT;
  561. if (forWrite) {
  562. usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
  563. }
  564. const VkImageCreateInfo imageCreateInfo = {
  565. VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
  566. &externalMemoryImageInfo, // pNext
  567. 0, // VkImageCreateFlags
  568. VK_IMAGE_TYPE_2D, // VkImageType
  569. hwbFormatProps.format, // VkFormat
  570. { DEV_W, DEV_H, 1 }, // VkExtent3D
  571. 1, // mipLevels
  572. 1, // arrayLayers
  573. VK_SAMPLE_COUNT_1_BIT, // samples
  574. VK_IMAGE_TILING_OPTIMAL, // VkImageTiling
  575. usageFlags, // VkImageUsageFlags
  576. VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode
  577. 0, // queueFamilyCount
  578. 0, // pQueueFamilyIndices
  579. VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
  580. };
  581. err = fVkCreateImage(fDevice, &imageCreateInfo, nullptr, &fImage);
  582. if (VK_SUCCESS != err) {
  583. ERRORF(reporter, "Create Image failed, err: %d", err);
  584. return false;
  585. }
  586. VkPhysicalDeviceMemoryProperties2 phyDevMemProps;
  587. phyDevMemProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
  588. phyDevMemProps.pNext = nullptr;
  589. uint32_t typeIndex = 0;
  590. uint32_t heapIndex = 0;
  591. bool foundHeap = false;
  592. fVkGetPhysicalDeviceMemoryProperties2(fBackendContext.fPhysicalDevice, &phyDevMemProps);
  593. uint32_t memTypeCnt = phyDevMemProps.memoryProperties.memoryTypeCount;
  594. for (uint32_t i = 0; i < memTypeCnt && !foundHeap; ++i) {
  595. if (hwbProps.memoryTypeBits & (1 << i)) {
  596. const VkPhysicalDeviceMemoryProperties& pdmp = phyDevMemProps.memoryProperties;
  597. uint32_t supportedFlags = pdmp.memoryTypes[i].propertyFlags &
  598. VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
  599. if (supportedFlags == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
  600. typeIndex = i;
  601. heapIndex = pdmp.memoryTypes[i].heapIndex;
  602. foundHeap = true;
  603. }
  604. }
  605. }
  606. if (!foundHeap) {
  607. ERRORF(reporter, "Failed to find valid heap for imported memory");
  608. return false;
  609. }
  610. VkImportAndroidHardwareBufferInfoANDROID hwbImportInfo;
  611. hwbImportInfo.sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
  612. hwbImportInfo.pNext = nullptr;
  613. hwbImportInfo.buffer = buffer;
  614. VkMemoryDedicatedAllocateInfo dedicatedAllocInfo;
  615. dedicatedAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
  616. dedicatedAllocInfo.pNext = &hwbImportInfo;
  617. dedicatedAllocInfo.image = fImage;
  618. dedicatedAllocInfo.buffer = VK_NULL_HANDLE;
  619. VkMemoryAllocateInfo allocInfo = {
  620. VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType
  621. &dedicatedAllocInfo, // pNext
  622. hwbProps.allocationSize, // allocationSize
  623. typeIndex, // memoryTypeIndex
  624. };
  625. err = fVkAllocateMemory(fDevice, &allocInfo, nullptr, &fMemory);
  626. if (VK_SUCCESS != err) {
  627. ERRORF(reporter, "AllocateMemory failed for imported buffer, err: %d", err);
  628. return false;
  629. }
  630. VkBindImageMemoryInfo bindImageInfo;
  631. bindImageInfo.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
  632. bindImageInfo.pNext = nullptr;
  633. bindImageInfo.image = fImage;
  634. bindImageInfo.memory = fMemory;
  635. bindImageInfo.memoryOffset = 0;
  636. err = fVkBindImageMemory2(fDevice, 1, &bindImageInfo);
  637. if (VK_SUCCESS != err) {
  638. ERRORF(reporter, "BindImageMemory failed for imported buffer, err: %d", err);
  639. return false;
  640. }
  641. outImageInfo->fImage = fImage;
  642. outImageInfo->fAlloc = GrVkAlloc(fMemory, 0, hwbProps.allocationSize, 0);
  643. outImageInfo->fImageTiling = VK_IMAGE_TILING_OPTIMAL;
  644. outImageInfo->fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  645. outImageInfo->fFormat = VK_FORMAT_R8G8B8A8_UNORM;
  646. outImageInfo->fLevelCount = 1;
  647. outImageInfo->fCurrentQueueFamily = VK_QUEUE_FAMILY_EXTERNAL;
  648. return true;
  649. }
  650. sk_sp<SkImage> VulkanTestHelper::importHardwareBufferForRead(skiatest::Reporter* reporter,
  651. AHardwareBuffer* buffer) {
  652. GrVkImageInfo imageInfo;
  653. if (!this->importHardwareBuffer(reporter, buffer, false, &imageInfo)) {
  654. return nullptr;
  655. }
  656. GrBackendTexture backendTex(DEV_W, DEV_H, imageInfo);
  657. sk_sp<SkImage> wrappedImage = SkImage::MakeFromTexture(fGrContext.get(),
  658. backendTex,
  659. kTopLeft_GrSurfaceOrigin,
  660. kRGBA_8888_SkColorType,
  661. kPremul_SkAlphaType,
  662. nullptr);
  663. if (!wrappedImage.get()) {
  664. ERRORF(reporter, "Failed to create wrapped Vulkan SkImage");
  665. return nullptr;
  666. }
  667. return wrappedImage;
  668. }
  669. bool VulkanTestHelper::flushSurfaceAndSignalSemaphore(skiatest::Reporter* reporter,
  670. sk_sp<SkSurface> surface) {
  671. surface->flush();
  672. surface.reset();
  673. GrBackendSemaphore semaphore;
  674. if (!this->setupSemaphoreForSignaling(reporter, &semaphore)) {
  675. return false;
  676. }
  677. GrFlushInfo info;
  678. info.fNumSemaphores = 1;
  679. info.fSignalSemaphores = &semaphore;
  680. GrSemaphoresSubmitted submitted = fGrContext->flush(info);
  681. if (GrSemaphoresSubmitted::kNo == submitted) {
  682. ERRORF(reporter, "Failing call to flush on GrContext");
  683. return false;
  684. }
  685. SkASSERT(semaphore.isInitialized());
  686. if (!this->exportSemaphore(reporter, semaphore)) {
  687. return false;
  688. }
  689. return true;
  690. }
  691. bool VulkanTestHelper::setupSemaphoreForSignaling(skiatest::Reporter* reporter,
  692. GrBackendSemaphore* beSemaphore) {
  693. // Query supported info
  694. VkPhysicalDeviceExternalSemaphoreInfo exSemInfo;
  695. exSemInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
  696. exSemInfo.pNext = nullptr;
  697. exSemInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
  698. VkExternalSemaphoreProperties exSemProps;
  699. exSemProps.sType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
  700. exSemProps.pNext = nullptr;
  701. fVkGetPhysicalDeviceExternalSemaphoreProperties(fBackendContext.fPhysicalDevice, &exSemInfo,
  702. &exSemProps);
  703. if (!SkToBool(exSemProps.exportFromImportedHandleTypes &
  704. VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT)) {
  705. ERRORF(reporter, "HANDLE_TYPE_SYNC_FD not listed as exportFromImportedHandleTypes");
  706. return false;
  707. }
  708. if (!SkToBool(exSemProps.compatibleHandleTypes &
  709. VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT)) {
  710. ERRORF(reporter, "HANDLE_TYPE_SYNC_FD not listed as compatibleHandleTypes");
  711. return false;
  712. }
  713. if (!SkToBool(exSemProps.externalSemaphoreFeatures &
  714. VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) ||
  715. !SkToBool(exSemProps.externalSemaphoreFeatures &
  716. VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT)) {
  717. ERRORF(reporter, "HANDLE_TYPE_SYNC_FD doesn't support export and import feature");
  718. return false;
  719. }
  720. VkExportSemaphoreCreateInfo exportInfo;
  721. exportInfo.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
  722. exportInfo.pNext = nullptr;
  723. exportInfo.handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
  724. VkSemaphoreCreateInfo semaphoreInfo;
  725. semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
  726. semaphoreInfo.pNext = &exportInfo;
  727. semaphoreInfo.flags = 0;
  728. VkSemaphore semaphore;
  729. VkResult err = fVkCreateSemaphore(fDevice, &semaphoreInfo, nullptr, &semaphore);
  730. if (VK_SUCCESS != err) {
  731. ERRORF(reporter, "Failed to create signal semaphore, err: %d", err);
  732. return false;
  733. }
  734. beSemaphore->initVulkan(semaphore);
  735. return true;
  736. }
  737. bool VulkanTestHelper::exportSemaphore(skiatest::Reporter* reporter,
  738. const GrBackendSemaphore& beSemaphore) {
  739. VkSemaphore semaphore = beSemaphore.vkSemaphore();
  740. if (VK_NULL_HANDLE == semaphore) {
  741. ERRORF(reporter, "Invalid vulkan handle in export call");
  742. return false;
  743. }
  744. VkSemaphoreGetFdInfoKHR getFdInfo;
  745. getFdInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR;
  746. getFdInfo.pNext = nullptr;
  747. getFdInfo.semaphore = semaphore;
  748. getFdInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
  749. VkResult err = fVkGetSemaphoreFdKHR(fDevice, &getFdInfo, &fFdHandle);
  750. if (VK_SUCCESS != err) {
  751. ERRORF(reporter, "Failed to export signal semaphore, err: %d", err);
  752. return false;
  753. }
  754. fSignalSemaphore = semaphore;
  755. return true;
  756. }
  757. bool VulkanTestHelper::importAndWaitOnSemaphore(skiatest::Reporter* reporter, int fdHandle,
  758. sk_sp<SkSurface> surface) {
  759. VkSemaphoreCreateInfo semaphoreInfo;
  760. semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
  761. semaphoreInfo.pNext = nullptr;
  762. semaphoreInfo.flags = 0;
  763. VkSemaphore semaphore;
  764. VkResult err = fVkCreateSemaphore(fDevice, &semaphoreInfo, nullptr, &semaphore);
  765. if (VK_SUCCESS != err) {
  766. ERRORF(reporter, "Failed to create import semaphore, err: %d", err);
  767. return false;
  768. }
  769. VkImportSemaphoreFdInfoKHR importInfo;
  770. importInfo.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR;
  771. importInfo.pNext = nullptr;
  772. importInfo.semaphore = semaphore;
  773. importInfo.flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT;
  774. importInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
  775. importInfo.fd = fdHandle;
  776. err = fVkImportSemaphoreFdKHR(fDevice, &importInfo);
  777. if (VK_SUCCESS != err) {
  778. ERRORF(reporter, "Failed to import semaphore, err: %d", err);
  779. return false;
  780. }
  781. GrBackendSemaphore beSemaphore;
  782. beSemaphore.initVulkan(semaphore);
  783. if (!surface->wait(1, &beSemaphore)) {
  784. ERRORF(reporter, "Failed to add wait semaphore to surface");
  785. fVkDestroySemaphore(fDevice, semaphore, nullptr);
  786. return false;
  787. }
  788. return true;
  789. }
  790. sk_sp<SkSurface> VulkanTestHelper::importHardwareBufferForWrite(skiatest::Reporter* reporter,
  791. AHardwareBuffer* buffer) {
  792. GrVkImageInfo imageInfo;
  793. if (!this->importHardwareBuffer(reporter, buffer, true, &imageInfo)) {
  794. return nullptr;
  795. }
  796. GrBackendTexture backendTex(DEV_W, DEV_H, imageInfo);
  797. sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(fGrContext.get(),
  798. backendTex,
  799. kTopLeft_GrSurfaceOrigin,
  800. 0,
  801. kRGBA_8888_SkColorType,
  802. nullptr, nullptr);
  803. if (!surface.get()) {
  804. ERRORF(reporter, "Failed to create wrapped Vulkan SkSurface");
  805. return nullptr;
  806. }
  807. return surface;
  808. }
  809. static SkPMColor get_src_color(int x, int y) {
  810. SkASSERT(x >= 0 && x < DEV_W);
  811. SkASSERT(y >= 0 && y < DEV_H);
  812. U8CPU r = x;
  813. U8CPU g = y;
  814. U8CPU b = 0xc;
  815. U8CPU a = 0xff;
  816. switch ((x+y) % 5) {
  817. case 0:
  818. a = 0xff;
  819. break;
  820. case 1:
  821. a = 0x80;
  822. break;
  823. case 2:
  824. a = 0xCC;
  825. break;
  826. case 4:
  827. a = 0x01;
  828. break;
  829. case 3:
  830. a = 0x00;
  831. break;
  832. }
  833. a = 0xff;
  834. return SkPremultiplyARGBInline(a, r, g, b);
  835. }
  836. static SkBitmap make_src_bitmap() {
  837. static SkBitmap bmp;
  838. if (bmp.isNull()) {
  839. bmp.allocN32Pixels(DEV_W, DEV_H);
  840. intptr_t pixels = reinterpret_cast<intptr_t>(bmp.getPixels());
  841. for (int y = 0; y < DEV_H; ++y) {
  842. for (int x = 0; x < DEV_W; ++x) {
  843. SkPMColor* pixel = reinterpret_cast<SkPMColor*>(
  844. pixels + y * bmp.rowBytes() + x * bmp.bytesPerPixel());
  845. *pixel = get_src_color(x, y);
  846. }
  847. }
  848. }
  849. return bmp;
  850. }
  851. static bool check_read(skiatest::Reporter* reporter, const SkBitmap& srcBitmap,
  852. const SkBitmap& dstBitmap) {
  853. bool result = true;
  854. for (int y = 0; y < DEV_H && result; ++y) {
  855. for (int x = 0; x < DEV_W && result; ++x) {
  856. const uint32_t srcPixel = *srcBitmap.getAddr32(x, y);
  857. const uint32_t dstPixel = *dstBitmap.getAddr32(x, y);
  858. if (srcPixel != dstPixel) {
  859. ERRORF(reporter, "Expected readback pixel (%d, %d) value 0x%08x, got 0x%08x.",
  860. x, y, srcPixel, dstPixel);
  861. result = false;
  862. } /*else {
  863. ERRORF(reporter, "Got good readback pixel (%d, %d) value 0x%08x, got 0x%08x.",
  864. x, y, srcPixel, dstPixel);
  865. }*/
  866. }
  867. }
  868. return result;
  869. }
  870. static void cleanup_resources(BaseTestHelper* srcHelper, BaseTestHelper* dstHelper,
  871. AHardwareBuffer* buffer) {
  872. if (srcHelper) {
  873. srcHelper->cleanup();
  874. }
  875. if (dstHelper) {
  876. dstHelper->cleanup();
  877. }
  878. if (buffer) {
  879. AHardwareBuffer_release(buffer);
  880. }
  881. }
  882. enum class SrcType {
  883. kCPU,
  884. kEGL,
  885. kVulkan,
  886. };
  887. enum class DstType {
  888. kEGL,
  889. kVulkan,
  890. };
  891. void run_test(skiatest::Reporter* reporter, const GrContextOptions& options,
  892. SrcType srcType, DstType dstType, bool shareSyncs) {
  893. if (SrcType::kCPU == srcType && shareSyncs) {
  894. // We don't currently test this since we don't do any syncs in this case.
  895. return;
  896. }
  897. std::unique_ptr<BaseTestHelper> srcHelper;
  898. std::unique_ptr<BaseTestHelper> dstHelper;
  899. AHardwareBuffer* buffer = nullptr;
  900. if (SrcType::kVulkan == srcType) {
  901. srcHelper.reset(new VulkanTestHelper());
  902. } else if (SrcType::kEGL == srcType) {
  903. srcHelper.reset(new EGLTestHelper(options));
  904. }
  905. if (srcHelper) {
  906. if (!srcHelper->init(reporter)) {
  907. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  908. return;
  909. }
  910. }
  911. if (DstType::kVulkan == dstType) {
  912. dstHelper.reset(new VulkanTestHelper());
  913. } else {
  914. SkASSERT(DstType::kEGL == dstType);
  915. dstHelper.reset(new EGLTestHelper(options));
  916. }
  917. if (dstHelper) {
  918. if (!dstHelper->init(reporter)) {
  919. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  920. return;
  921. }
  922. }
  923. ///////////////////////////////////////////////////////////////////////////
  924. // Setup SkBitmaps
  925. ///////////////////////////////////////////////////////////////////////////
  926. SkBitmap srcBitmap = make_src_bitmap();
  927. SkBitmap dstBitmapSurface;
  928. dstBitmapSurface.allocN32Pixels(DEV_W, DEV_H);
  929. SkBitmap dstBitmapFinal;
  930. dstBitmapFinal.allocN32Pixels(DEV_W, DEV_H);
  931. ///////////////////////////////////////////////////////////////////////////
  932. // Setup AHardwareBuffer
  933. ///////////////////////////////////////////////////////////////////////////
  934. AHardwareBuffer_Desc hwbDesc;
  935. hwbDesc.width = DEV_W;
  936. hwbDesc.height = DEV_H;
  937. hwbDesc.layers = 1;
  938. if (SrcType::kCPU == srcType) {
  939. hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
  940. AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
  941. AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
  942. } else {
  943. hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
  944. AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER |
  945. AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
  946. AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
  947. }
  948. hwbDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
  949. // The following three are not used in the allocate
  950. hwbDesc.stride = 0;
  951. hwbDesc.rfu0= 0;
  952. hwbDesc.rfu1= 0;
  953. if (int error = AHardwareBuffer_allocate(&hwbDesc, &buffer)) {
  954. ERRORF(reporter, "Failed to allocated hardware buffer, error: %d", error);
  955. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  956. return;
  957. }
  958. if (SrcType::kCPU == srcType) {
  959. // Get actual desc for allocated buffer so we know the stride for uploading cpu data.
  960. AHardwareBuffer_describe(buffer, &hwbDesc);
  961. uint32_t* bufferAddr;
  962. if (AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1, nullptr,
  963. reinterpret_cast<void**>(&bufferAddr))) {
  964. ERRORF(reporter, "Failed to lock hardware buffer");
  965. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  966. return;
  967. }
  968. int bbp = srcBitmap.bytesPerPixel();
  969. uint32_t* src = (uint32_t*)srcBitmap.getPixels();
  970. uint32_t* dst = bufferAddr;
  971. for (int y = 0; y < DEV_H; ++y) {
  972. memcpy(dst, src, DEV_W * bbp);
  973. src += DEV_W;
  974. dst += hwbDesc.stride;
  975. }
  976. for (int y = 0; y < DEV_H; ++y) {
  977. for (int x = 0; x < DEV_W; ++x) {
  978. const uint32_t srcPixel = *srcBitmap.getAddr32(x, y);
  979. uint32_t dstPixel = bufferAddr[y * hwbDesc.stride + x];
  980. if (srcPixel != dstPixel) {
  981. ERRORF(reporter, "CPU HWB Expected readpix (%d, %d) value 0x%08x, got 0x%08x.",
  982. x, y, srcPixel, dstPixel);
  983. }
  984. }
  985. }
  986. AHardwareBuffer_unlock(buffer, nullptr);
  987. } else {
  988. srcHelper->makeCurrent();
  989. sk_sp<SkSurface> surface = srcHelper->importHardwareBufferForWrite(reporter, buffer);
  990. if (!surface) {
  991. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  992. return;
  993. }
  994. sk_sp<SkImage> srcBmpImage = SkImage::MakeFromBitmap(srcBitmap);
  995. surface->getCanvas()->drawImage(srcBmpImage, 0, 0);
  996. // If we are testing sharing of syncs, don't do a read here since it forces sychronization
  997. // to occur.
  998. if (!shareSyncs) {
  999. bool readResult = surface->readPixels(dstBitmapSurface, 0, 0);
  1000. if (!readResult) {
  1001. ERRORF(reporter, "Read Pixels on surface failed");
  1002. surface.reset();
  1003. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1004. return;
  1005. }
  1006. REPORTER_ASSERT(reporter, check_read(reporter, srcBitmap, dstBitmapSurface));
  1007. }
  1008. ///////////////////////////////////////////////////////////////////////////
  1009. // Cleanup GL/EGL and add syncs
  1010. ///////////////////////////////////////////////////////////////////////////
  1011. if (shareSyncs) {
  1012. if (!srcHelper->flushSurfaceAndSignalSemaphore(reporter, std::move(surface))) {
  1013. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1014. return;
  1015. }
  1016. } else {
  1017. surface.reset();
  1018. srcHelper->doClientSync();
  1019. srcHelper->releaseImage();
  1020. }
  1021. }
  1022. ///////////////////////////////////////////////////////////////////////////
  1023. // Import the HWB into backend and draw it to a surface
  1024. ///////////////////////////////////////////////////////////////////////////
  1025. dstHelper->makeCurrent();
  1026. sk_sp<SkImage> wrappedImage = dstHelper->importHardwareBufferForRead(reporter, buffer);
  1027. if (!wrappedImage) {
  1028. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1029. return;
  1030. }
  1031. GrContext* grContext = dstHelper->grContext();
  1032. // Make SkSurface to render wrapped HWB into.
  1033. SkImageInfo imageInfo = SkImageInfo::Make(DEV_W, DEV_H, kRGBA_8888_SkColorType,
  1034. kPremul_SkAlphaType, nullptr);
  1035. sk_sp<SkSurface> dstSurf = SkSurface::MakeRenderTarget(grContext,
  1036. SkBudgeted::kNo, imageInfo, 0,
  1037. kTopLeft_GrSurfaceOrigin,
  1038. nullptr, false);
  1039. if (!dstSurf.get()) {
  1040. ERRORF(reporter, "Failed to create destination SkSurface");
  1041. wrappedImage.reset();
  1042. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1043. return;
  1044. }
  1045. if (shareSyncs) {
  1046. if (!dstHelper->importAndWaitOnSemaphore(reporter, srcHelper->getFdHandle(), dstSurf)) {
  1047. wrappedImage.reset();
  1048. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1049. return;
  1050. }
  1051. }
  1052. dstSurf->getCanvas()->drawImage(wrappedImage, 0, 0);
  1053. bool readResult = dstSurf->readPixels(dstBitmapFinal, 0, 0);
  1054. if (!readResult) {
  1055. ERRORF(reporter, "Read Pixels failed");
  1056. wrappedImage.reset();
  1057. dstSurf.reset();
  1058. dstHelper->doClientSync();
  1059. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1060. return;
  1061. }
  1062. REPORTER_ASSERT(reporter, check_read(reporter, srcBitmap, dstBitmapFinal));
  1063. dstSurf.reset();
  1064. wrappedImage.reset();
  1065. dstHelper->doClientSync();
  1066. cleanup_resources(srcHelper.get(), dstHelper.get(), buffer);
  1067. }
  1068. DEF_GPUTEST(VulkanHardwareBuffer_CPU_Vulkan, reporter, options) {
  1069. run_test(reporter, options, SrcType::kCPU, DstType::kVulkan, false);
  1070. }
  1071. DEF_GPUTEST(VulkanHardwareBuffer_EGL_Vulkan, reporter, options) {
  1072. run_test(reporter, options, SrcType::kEGL, DstType::kVulkan, false);
  1073. }
  1074. DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_Vulkan, reporter, options) {
  1075. run_test(reporter, options, SrcType::kVulkan, DstType::kVulkan, false);
  1076. }
  1077. DEF_GPUTEST(VulkanHardwareBuffer_CPU_EGL, reporter, options) {
  1078. run_test(reporter, options, SrcType::kCPU, DstType::kEGL, false);
  1079. }
  1080. DEF_GPUTEST(VulkanHardwareBuffer_EGL_EGL, reporter, options) {
  1081. run_test(reporter, options, SrcType::kEGL, DstType::kEGL, false);
  1082. }
  1083. DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_EGL, reporter, options) {
  1084. run_test(reporter, options, SrcType::kVulkan, DstType::kEGL, false);
  1085. }
  1086. DEF_GPUTEST(VulkanHardwareBuffer_EGL_EGL_Syncs, reporter, options) {
  1087. run_test(reporter, options, SrcType::kEGL, DstType::kEGL, true);
  1088. }
  1089. DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_EGL_Syncs, reporter, options) {
  1090. run_test(reporter, options, SrcType::kVulkan, DstType::kEGL, true);
  1091. }
  1092. DEF_GPUTEST(VulkanHardwareBuffer_EGL_Vulkan_Syncs, reporter, options) {
  1093. run_test(reporter, options, SrcType::kEGL, DstType::kVulkan, true);
  1094. }
  1095. DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_Vulkan_Syncs, reporter, options) {
  1096. run_test(reporter, options, SrcType::kVulkan, DstType::kVulkan, true);
  1097. }
  1098. #endif