blob: a257f06755f2aea0f7ac1e8b1f98cff14dce1430 [file] [log] [blame]
Jesse Hallb1352bc2015-09-04 16:12:33 -07001/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -080017#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
Trevor David Blackf499b5a2023-07-14 17:30:41 +000019#include <aidl/android/hardware/graphics/common/PixelFormat.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070020#include <android/hardware/graphics/common/1.0/types.h>
Jesse Hall79927812017-03-23 11:03:23 -070021#include <grallocusage/GrallocUsageConversion.h>
Yiwei Zhang69395cd2019-07-03 16:55:39 -070022#include <graphicsenv/GraphicsEnv.h>
John Reck97678d42022-08-23 11:24:51 -040023#include <hardware/gralloc.h>
24#include <hardware/gralloc1.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070025#include <log/log.h>
Jesse Halld7b994a2015-09-07 14:17:37 -070026#include <sync/sync.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070027#include <system/window.h>
28#include <ui/BufferQueueDefs.h>
Chia-I Wue8e689f2016-04-18 08:21:31 +080029#include <utils/StrongPointer.h>
Yiwei Zhang705c2e62019-12-18 23:12:43 -080030#include <utils/Timers.h>
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -080031#include <utils/Trace.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070032
33#include <algorithm>
34#include <unordered_set>
35#include <vector>
Jesse Halld7b994a2015-09-07 14:17:37 -070036
Chia-I Wu4a6a9162016-03-26 07:17:34 +080037#include "driver.h"
Jesse Halld7b994a2015-09-07 14:17:37 -070038
Trevor David Blackf499b5a2023-07-14 17:30:41 +000039using PixelFormat = aidl::android::hardware::graphics::common::PixelFormat;
Daniel Kochf25f5bb2017-10-05 00:26:58 -040040using android::hardware::graphics::common::V1_0::BufferUsage;
41
Chia-I Wu62262232016-03-26 07:06:44 +080042namespace vulkan {
43namespace driver {
Jesse Hall5ae3abb2015-10-08 14:00:22 -070044
Jesse Halld7b994a2015-09-07 14:17:37 -070045namespace {
46
John Reck97678d42022-08-23 11:24:51 -040047static uint64_t convertGralloc1ToBufferUsage(uint64_t producerUsage,
48 uint64_t consumerUsage) {
49 static_assert(uint64_t(GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN) ==
50 uint64_t(GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN),
51 "expected ConsumerUsage and ProducerUsage CPU_READ_OFTEN "
52 "bits to match");
53 uint64_t merged = producerUsage | consumerUsage;
54 if ((merged & (GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN)) ==
55 GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN) {
56 merged &= ~uint64_t(GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN);
57 merged |= BufferUsage::CPU_READ_OFTEN;
58 }
59 if ((merged & (GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN)) ==
60 GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN) {
61 merged &= ~uint64_t(GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN);
62 merged |= BufferUsage::CPU_WRITE_OFTEN;
63 }
64 return merged;
65}
66
Jesse Hall55bc0972016-02-23 16:43:29 -080067const VkSurfaceTransformFlagsKHR kSupportedTransforms =
68 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
69 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
70 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
71 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
Yiwei Zhang70a21962019-05-31 17:26:52 -070072 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
73 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
74 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
75 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
Jesse Hall55bc0972016-02-23 16:43:29 -080076 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
77
78VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
79 // Native and Vulkan transforms are isomorphic, but are represented
80 // differently. Vulkan transforms are built up of an optional horizontal
81 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
82 // transforms are built up from a horizontal flip, vertical flip, and
83 // 90-degree rotation, all optional but always in that order.
84
Jesse Hall55bc0972016-02-23 16:43:29 -080085 switch (native) {
Yiwei Zhang70a21962019-05-31 17:26:52 -070086 case 0:
Jesse Hall55bc0972016-02-23 16:43:29 -080087 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070088 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
89 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
90 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
91 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
92 case NATIVE_WINDOW_TRANSFORM_ROT_180:
Jesse Hall55bc0972016-02-23 16:43:29 -080093 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070094 case NATIVE_WINDOW_TRANSFORM_ROT_90:
Jesse Hall55bc0972016-02-23 16:43:29 -080095 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070096 case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
97 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
98 case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
99 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
100 case NATIVE_WINDOW_TRANSFORM_ROT_270:
Jesse Hall55bc0972016-02-23 16:43:29 -0800101 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
102 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
103 default:
104 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
105 }
106}
107
Yiwei Zhang70a21962019-05-31 17:26:52 -0700108int TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform) {
109 switch (transform) {
110 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
111 return NATIVE_WINDOW_TRANSFORM_ROT_90;
112 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
113 return NATIVE_WINDOW_TRANSFORM_ROT_180;
114 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
115 return NATIVE_WINDOW_TRANSFORM_ROT_270;
116 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
117 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
118 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
119 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
120 NATIVE_WINDOW_TRANSFORM_ROT_90;
121 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
122 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
123 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
124 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
125 NATIVE_WINDOW_TRANSFORM_ROT_90;
126 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
127 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
128 default:
129 return 0;
130 }
131}
132
Jesse Hall178b6962016-02-24 15:39:50 -0800133int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
134 switch (transform) {
135 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
136 return NATIVE_WINDOW_TRANSFORM_ROT_270;
137 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
138 return NATIVE_WINDOW_TRANSFORM_ROT_180;
139 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
140 return NATIVE_WINDOW_TRANSFORM_ROT_90;
Yiwei Zhang70a21962019-05-31 17:26:52 -0700141 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
142 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
143 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
144 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
145 NATIVE_WINDOW_TRANSFORM_ROT_90;
146 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
147 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
148 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
149 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
150 NATIVE_WINDOW_TRANSFORM_ROT_90;
Jesse Hall178b6962016-02-24 15:39:50 -0800151 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
152 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
153 default:
154 return 0;
155 }
156}
157
Ian Elliott8a977262017-01-19 09:05:58 -0700158class TimingInfo {
159 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800160 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
Ian Elliott2c6355d2017-01-19 11:02:13 -0700161 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
Brian Anderson1049d1d2016-12-16 17:25:57 -0800162 native_frame_id_(nativeFrameId) {}
163 bool ready() const {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700164 return (timestamp_desired_present_time_ !=
165 NATIVE_WINDOW_TIMESTAMP_PENDING &&
166 timestamp_actual_present_time_ !=
167 NATIVE_WINDOW_TIMESTAMP_PENDING &&
168 timestamp_render_complete_time_ !=
169 NATIVE_WINDOW_TIMESTAMP_PENDING &&
170 timestamp_composition_latch_time_ !=
171 NATIVE_WINDOW_TIMESTAMP_PENDING);
Ian Elliott8a977262017-01-19 09:05:58 -0700172 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700173 void calculate(int64_t rdur) {
174 bool anyTimestampInvalid =
175 (timestamp_actual_present_time_ ==
176 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
177 (timestamp_render_complete_time_ ==
178 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
179 (timestamp_composition_latch_time_ ==
180 NATIVE_WINDOW_TIMESTAMP_INVALID);
181 if (anyTimestampInvalid) {
182 ALOGE("Unexpectedly received invalid timestamp.");
183 vals_.actualPresentTime = 0;
184 vals_.earliestPresentTime = 0;
185 vals_.presentMargin = 0;
186 return;
187 }
188
189 vals_.actualPresentTime =
190 static_cast<uint64_t>(timestamp_actual_present_time_);
191 int64_t margin = (timestamp_composition_latch_time_ -
Ian Elliott8a977262017-01-19 09:05:58 -0700192 timestamp_render_complete_time_);
193 // Calculate vals_.earliestPresentTime, and potentially adjust
194 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
195 // is vals_.actualPresentTime. If we can subtract rdur (the duration
196 // of a refresh cycle) from vals_.earliestPresentTime (and also from
197 // vals_.presentMargin) and still leave a positive margin, then we can
198 // report to the application that it could have presented earlier than
199 // it did (per the extension specification). If for some reason, we
200 // can do this subtraction repeatedly, we do, since
201 // vals_.earliestPresentTime really is supposed to be the "earliest".
Brian Andersondc96fdf2017-03-20 16:54:25 -0700202 int64_t early_time = timestamp_actual_present_time_;
Ian Elliott8a977262017-01-19 09:05:58 -0700203 while ((margin > rdur) &&
204 ((early_time - rdur) > timestamp_composition_latch_time_)) {
205 early_time -= rdur;
206 margin -= rdur;
207 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700208 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
209 vals_.presentMargin = static_cast<uint64_t>(margin);
Ian Elliott8a977262017-01-19 09:05:58 -0700210 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800211 void get_values(VkPastPresentationTimingGOOGLE* values) const {
212 *values = vals_;
213 }
Ian Elliott8a977262017-01-19 09:05:58 -0700214
215 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800216 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700217
Brian Anderson1049d1d2016-12-16 17:25:57 -0800218 uint64_t native_frame_id_ { 0 };
Brian Andersondc96fdf2017-03-20 16:54:25 -0700219 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
220 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
221 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
222 int64_t timestamp_composition_latch_time_
223 { NATIVE_WINDOW_TIMESTAMP_PENDING };
Ian Elliott8a977262017-01-19 09:05:58 -0700224};
225
Jesse Hall1356b0d2015-11-23 17:24:58 -0800226struct Surface {
Chia-I Wue8e689f2016-04-18 08:21:31 +0800227 android::sp<ANativeWindow> window;
Jesse Halldc225072016-05-30 22:40:14 -0700228 VkSwapchainKHR swapchain_handle;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700229 uint64_t consumer_usage;
Yiwei Zhang3b88f312023-04-18 23:11:35 +0000230
231 // Indicate whether this surface has been used by a swapchain, no matter the
232 // swapchain is still current or has been destroyed.
233 bool used_by_swapchain;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800234};
235
236VkSurfaceKHR HandleFromSurface(Surface* surface) {
237 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
238}
239
240Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800241 return reinterpret_cast<Surface*>(handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800242}
243
Ian Elliott8a977262017-01-19 09:05:58 -0700244// Maximum number of TimingInfo structs to keep per swapchain:
245enum { MAX_TIMING_INFOS = 10 };
246// Minimum number of frames to look for in the past (so we don't cause
247// syncronous requests to Surface Flinger):
248enum { MIN_NUM_FRAMES_AGO = 5 };
249
Chris Forbes4cd01fb2022-10-19 11:35:16 +1300250bool IsSharedPresentMode(VkPresentModeKHR mode) {
251 return mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
252 mode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
253}
254
Jesse Hall1356b0d2015-11-23 17:24:58 -0800255struct Swapchain {
Ian Elliottffedb652017-02-14 10:58:30 -0700256 Swapchain(Surface& surface_,
257 uint32_t num_images_,
silence_dogood73597592019-05-23 16:57:37 -0700258 VkPresentModeKHR present_mode,
Alina Kalyakina3d6f3632023-03-22 17:13:47 +0000259 int pre_transform_,
260 int64_t refresh_duration_)
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700261 : surface(surface_),
262 num_images(num_images_),
Ian Elliottffedb652017-02-14 10:58:30 -0700263 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
silence_dogood73597592019-05-23 16:57:37 -0700264 pre_transform(pre_transform_),
Chris Forbesf8835642017-03-30 19:31:40 +1300265 frame_timestamps_enabled(false),
Alina Kalyakina3d6f3632023-03-22 17:13:47 +0000266 refresh_duration(refresh_duration_),
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800267 acquire_next_image_timeout(-1),
Chris Forbes4cd01fb2022-10-19 11:35:16 +1300268 shared(IsSharedPresentMode(present_mode)) {
Ian Elliott8a977262017-01-19 09:05:58 -0700269 }
Alina Kalyakina3d6f3632023-03-22 17:13:47 +0000270
271 VkResult get_refresh_duration(uint64_t& outRefreshDuration)
Ian Elliott3568bfe2019-05-03 15:54:46 -0600272 {
273 ANativeWindow* window = surface.window.get();
Alina Kalyakina3d6f3632023-03-22 17:13:47 +0000274 int err = native_window_get_refresh_cycle_duration(
Ian Elliott3568bfe2019-05-03 15:54:46 -0600275 window,
276 &refresh_duration);
Alina Kalyakina3d6f3632023-03-22 17:13:47 +0000277 if (err != android::OK) {
278 ALOGE("%s:native_window_get_refresh_cycle_duration failed: %s (%d)",
279 __func__, strerror(-err), err );
280 return VK_ERROR_SURFACE_LOST_KHR;
281 }
282 outRefreshDuration = refresh_duration;
283 return VK_SUCCESS;
Ian Elliott3568bfe2019-05-03 15:54:46 -0600284 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800285
286 Surface& surface;
Jesse Halld7b994a2015-09-07 14:17:37 -0700287 uint32_t num_images;
Ian Elliottffedb652017-02-14 10:58:30 -0700288 bool mailbox_mode;
silence_dogood73597592019-05-23 16:57:37 -0700289 int pre_transform;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700290 bool frame_timestamps_enabled;
Brian Andersondc96fdf2017-03-20 16:54:25 -0700291 int64_t refresh_duration;
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800292 nsecs_t acquire_next_image_timeout;
Chris Forbesf8835642017-03-30 19:31:40 +1300293 bool shared;
Jesse Halld7b994a2015-09-07 14:17:37 -0700294
295 struct Image {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700296 Image()
297 : image(VK_NULL_HANDLE),
298 dequeue_fence(-1),
299 release_fence(-1),
300 dequeued(false) {}
Jesse Halld7b994a2015-09-07 14:17:37 -0700301 VkImage image;
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000302 // If the image is bound to memory, an sp to the underlying gralloc buffer.
303 // Otherwise, nullptr; the image will be bound to memory as part of
304 // AcquireNextImage.
Chia-I Wue8e689f2016-04-18 08:21:31 +0800305 android::sp<ANativeWindowBuffer> buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -0700306 // The fence is only valid when the buffer is dequeued, and should be
307 // -1 any other time. When valid, we own the fd, and must ensure it is
308 // closed: either by closing it explicitly when queueing the buffer,
309 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
310 int dequeue_fence;
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700311 // This fence is a dup of the sync fd returned from the driver via
312 // vkQueueSignalReleaseImageANDROID upon vkQueuePresentKHR. We must
313 // ensure it is closed upon re-presenting or releasing the image.
314 int release_fence;
Jesse Halld7b994a2015-09-07 14:17:37 -0700315 bool dequeued;
Pawin Vongmasa6e1193a2017-03-07 13:08:40 -0800316 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
Ian Elliott8a977262017-01-19 09:05:58 -0700317
Yiwei Zhang5e862202019-06-21 14:59:16 -0700318 std::vector<TimingInfo> timing;
Jesse Halld7b994a2015-09-07 14:17:37 -0700319};
320
321VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
322 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
323}
324
325Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800326 return reinterpret_cast<Swapchain*>(handle);
Jesse Halld7b994a2015-09-07 14:17:37 -0700327}
328
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700329static bool IsFencePending(int fd) {
330 if (fd < 0)
331 return false;
332
333 errno = 0;
334 return sync_wait(fd, 0 /* timeout */) == -1 && errno == ETIME;
335}
336
Jesse Halldc225072016-05-30 22:40:14 -0700337void ReleaseSwapchainImage(VkDevice device,
Yiwei Zhangac1f0982022-04-09 07:10:10 +0000338 bool shared_present,
Jesse Halldc225072016-05-30 22:40:14 -0700339 ANativeWindow* window,
340 int release_fence,
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700341 Swapchain::Image& image,
342 bool defer_if_pending) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700343 ATRACE_CALL();
344
Jesse Halldc225072016-05-30 22:40:14 -0700345 ALOG_ASSERT(release_fence == -1 || image.dequeued,
346 "ReleaseSwapchainImage: can't provide a release fence for "
347 "non-dequeued images");
348
349 if (image.dequeued) {
350 if (release_fence >= 0) {
351 // We get here from vkQueuePresentKHR. The application is
352 // responsible for creating an execution dependency chain from
353 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
354 // (release_fence), so we can drop the dequeue_fence here.
355 if (image.dequeue_fence >= 0)
356 close(image.dequeue_fence);
357 } else {
358 // We get here during swapchain destruction, or various serious
359 // error cases e.g. when we can't create the release_fence during
360 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
361 // have already signalled, since the swapchain images are supposed
362 // to be idle before the swapchain is destroyed. In error cases,
363 // there may be rendering in flight to the image, but since we
364 // weren't able to create a release_fence, waiting for the
365 // dequeue_fence is about the best we can do.
366 release_fence = image.dequeue_fence;
367 }
368 image.dequeue_fence = -1;
369
Yiwei Zhangac1f0982022-04-09 07:10:10 +0000370 // It's invalid to call cancelBuffer on a shared buffer
371 if (window && !shared_present) {
Jesse Halldc225072016-05-30 22:40:14 -0700372 window->cancelBuffer(window, image.buffer.get(), release_fence);
373 } else {
374 if (release_fence >= 0) {
375 sync_wait(release_fence, -1 /* forever */);
376 close(release_fence);
377 }
378 }
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700379 release_fence = -1;
Jesse Halldc225072016-05-30 22:40:14 -0700380 image.dequeued = false;
381 }
382
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700383 if (defer_if_pending && IsFencePending(image.release_fence))
384 return;
385
386 if (image.release_fence >= 0) {
387 close(image.release_fence);
388 image.release_fence = -1;
389 }
390
Jesse Halldc225072016-05-30 22:40:14 -0700391 if (image.image) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700392 ATRACE_BEGIN("DestroyImage");
Jesse Halldc225072016-05-30 22:40:14 -0700393 GetData(device).driver.DestroyImage(device, image.image, nullptr);
Yiwei Zhang533cea92019-06-03 18:43:24 -0700394 ATRACE_END();
Jesse Halldc225072016-05-30 22:40:14 -0700395 image.image = VK_NULL_HANDLE;
396 }
397
398 image.buffer.clear();
399}
400
401void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
402 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
403 return;
Jesse Halldc225072016-05-30 22:40:14 -0700404 for (uint32_t i = 0; i < swapchain->num_images; i++) {
Yiwei Zhangac1f0982022-04-09 07:10:10 +0000405 if (!swapchain->images[i].dequeued) {
406 ReleaseSwapchainImage(device, swapchain->shared, nullptr, -1,
407 swapchain->images[i], true);
408 }
Jesse Halldc225072016-05-30 22:40:14 -0700409 }
410 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Ian Elliott8a977262017-01-19 09:05:58 -0700411 swapchain->timing.clear();
412}
413
414uint32_t get_num_ready_timings(Swapchain& swapchain) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800415 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
416 return 0;
417 }
Ian Elliott8a977262017-01-19 09:05:58 -0700418
Brian Anderson1049d1d2016-12-16 17:25:57 -0800419 uint32_t num_ready = 0;
420 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
421 for (uint32_t i = 0; i < num_timings; i++) {
Yiwei Zhang5e862202019-06-21 14:59:16 -0700422 TimingInfo& ti = swapchain.timing[i];
Brian Anderson1049d1d2016-12-16 17:25:57 -0800423 if (ti.ready()) {
424 // This TimingInfo is ready to be reported to the user. Add it
425 // to the num_ready.
426 num_ready++;
427 continue;
428 }
429 // This TimingInfo is not yet ready to be reported to the user,
430 // and so we should look for any available timestamps that
431 // might make it ready.
432 int64_t desired_present_time = 0;
433 int64_t render_complete_time = 0;
434 int64_t composition_latch_time = 0;
435 int64_t actual_present_time = 0;
436 // Obtain timestamps:
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800437 int err = native_window_get_frame_timestamps(
Brian Anderson1049d1d2016-12-16 17:25:57 -0800438 swapchain.surface.window.get(), ti.native_frame_id_,
439 &desired_present_time, &render_complete_time,
440 &composition_latch_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700441 nullptr, //&first_composition_start_time,
442 nullptr, //&last_composition_start_time,
443 nullptr, //&composition_finish_time,
Brian Anderson1049d1d2016-12-16 17:25:57 -0800444 &actual_present_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700445 nullptr, //&dequeue_ready_time,
446 nullptr /*&reads_done_time*/);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800447
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800448 if (err != android::OK) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800449 continue;
450 }
451
452 // Record the timestamp(s) we received, and then see if this TimingInfo
453 // is ready to be reported to the user:
Brian Andersondc96fdf2017-03-20 16:54:25 -0700454 ti.timestamp_desired_present_time_ = desired_present_time;
455 ti.timestamp_actual_present_time_ = actual_present_time;
456 ti.timestamp_render_complete_time_ = render_complete_time;
457 ti.timestamp_composition_latch_time_ = composition_latch_time;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800458
459 if (ti.ready()) {
460 // The TimingInfo has received enough timestamps, and should now
461 // use those timestamps to calculate the info that should be
462 // reported to the user:
463 ti.calculate(swapchain.refresh_duration);
464 num_ready++;
Ian Elliott8a977262017-01-19 09:05:58 -0700465 }
466 }
467 return num_ready;
468}
469
Ian Elliott8a977262017-01-19 09:05:58 -0700470void copy_ready_timings(Swapchain& swapchain,
471 uint32_t* count,
472 VkPastPresentationTimingGOOGLE* timings) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800473 if (swapchain.timing.empty()) {
474 *count = 0;
475 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700476 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800477
478 size_t last_ready = swapchain.timing.size() - 1;
479 while (!swapchain.timing[last_ready].ready()) {
480 if (last_ready == 0) {
481 *count = 0;
482 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700483 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800484 last_ready--;
Ian Elliott8a977262017-01-19 09:05:58 -0700485 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800486
487 uint32_t num_copied = 0;
Yiwei Zhang5e862202019-06-21 14:59:16 -0700488 int32_t num_to_remove = 0;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800489 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
490 const TimingInfo& ti = swapchain.timing[i];
491 if (ti.ready()) {
492 ti.get_values(&timings[num_copied]);
493 num_copied++;
494 }
495 num_to_remove++;
496 }
497
498 // Discard old frames that aren't ready if newer frames are ready.
499 // We don't expect to get the timing info for those old frames.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700500 swapchain.timing.erase(swapchain.timing.begin(),
501 swapchain.timing.begin() + num_to_remove);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800502
Ian Elliott8a977262017-01-19 09:05:58 -0700503 *count = num_copied;
Jesse Halldc225072016-05-30 22:40:14 -0700504}
505
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000506PixelFormat GetNativePixelFormat(VkFormat format) {
507 PixelFormat native_format = PixelFormat::RGBA_8888;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700508 switch (format) {
509 case VK_FORMAT_R8G8B8A8_UNORM:
510 case VK_FORMAT_R8G8B8A8_SRGB:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000511 native_format = PixelFormat::RGBA_8888;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700512 break;
513 case VK_FORMAT_R5G6B5_UNORM_PACK16:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000514 native_format = PixelFormat::RGB_565;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700515 break;
516 case VK_FORMAT_R16G16B16A16_SFLOAT:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000517 native_format = PixelFormat::RGBA_FP16;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700518 break;
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800519 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000520 native_format = PixelFormat::RGBA_1010102;
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500521 break;
522 case VK_FORMAT_R8_UNORM:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000523 native_format = PixelFormat::R_8;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700524 break;
Trevor David Black9cfe1ed2022-12-05 20:04:57 +0000525 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
Trevor David Blackf499b5a2023-07-14 17:30:41 +0000526 native_format = PixelFormat::RGBA_10101010;
Trevor David Black9cfe1ed2022-12-05 20:04:57 +0000527 break;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700528 default:
529 ALOGV("unsupported swapchain format %d", format);
530 break;
531 }
532 return native_format;
533}
534
Sally Qi03a1a752023-07-17 12:52:05 +0800535android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace,
536 PixelFormat pixelFormat) {
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700537 switch (colorspace) {
538 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
539 return HAL_DATASPACE_V0_SRGB;
540 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
541 return HAL_DATASPACE_DISPLAY_P3;
542 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
543 return HAL_DATASPACE_V0_SCRGB_LINEAR;
Courtney Goeltzenleuchterb52abee2017-08-07 17:13:04 -0600544 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
545 return HAL_DATASPACE_V0_SCRGB;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700546 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
547 return HAL_DATASPACE_DCI_P3_LINEAR;
548 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
549 return HAL_DATASPACE_DCI_P3;
550 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
551 return HAL_DATASPACE_V0_SRGB_LINEAR;
552 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
553 return HAL_DATASPACE_V0_SRGB;
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600554 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
Sally Qi03a1a752023-07-17 12:52:05 +0800555 if (pixelFormat == PixelFormat::RGBA_FP16) {
556 return static_cast<android_dataspace>(
557 HAL_DATASPACE_STANDARD_BT2020 |
558 HAL_DATASPACE_TRANSFER_LINEAR |
559 HAL_DATASPACE_RANGE_EXTENDED);
560 } else {
561 return HAL_DATASPACE_BT2020_LINEAR;
562 }
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600563 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700564 return static_cast<android_dataspace>(
565 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
566 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600567 case VK_COLOR_SPACE_DOLBYVISION_EXT:
568 return static_cast<android_dataspace>(
569 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
570 HAL_DATASPACE_RANGE_FULL);
571 case VK_COLOR_SPACE_HDR10_HLG_EXT:
Sally Qi03a1a752023-07-17 12:52:05 +0800572 return static_cast<android_dataspace>(HAL_DATASPACE_BT2020_HLG);
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700573 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
574 return static_cast<android_dataspace>(
575 HAL_DATASPACE_STANDARD_ADOBE_RGB |
576 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
577 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
578 return HAL_DATASPACE_ADOBE_RGB;
579
580 // Pass through is intended to allow app to provide data that is passed
581 // to the display system without modification.
582 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
583 return HAL_DATASPACE_ARBITRARY;
584
585 default:
586 // This indicates that we don't know about the
587 // dataspace specified and we should indicate that
588 // it's unsupported
589 return HAL_DATASPACE_UNKNOWN;
590 }
591}
592
Jesse Halld7b994a2015-09-07 14:17:37 -0700593} // anonymous namespace
Jesse Hallb1352bc2015-09-04 16:12:33 -0700594
Jesse Halle1b12782015-11-30 11:27:32 -0800595VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800596VkResult CreateAndroidSurfaceKHR(
Jesse Hallf9fa9a52016-01-08 16:08:51 -0800597 VkInstance instance,
598 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
599 const VkAllocationCallbacks* allocator,
600 VkSurfaceKHR* out_surface) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800601 ATRACE_CALL();
602
Jesse Hall1f91d392015-12-11 16:28:44 -0800603 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800604 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800605 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
606 alignof(Surface),
607 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800608 if (!mem)
609 return VK_ERROR_OUT_OF_HOST_MEMORY;
610 Surface* surface = new (mem) Surface;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700611
Chia-I Wue8e689f2016-04-18 08:21:31 +0800612 surface->window = pCreateInfo->window;
Jesse Halldc225072016-05-30 22:40:14 -0700613 surface->swapchain_handle = VK_NULL_HANDLE;
Yiwei Zhang3b88f312023-04-18 23:11:35 +0000614 surface->used_by_swapchain = false;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700615 int err = native_window_get_consumer_usage(surface->window.get(),
616 &surface->consumer_usage);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800617 if (err != android::OK) {
Yiwei Zhang6435b322018-05-08 11:12:17 -0700618 ALOGE("native_window_get_consumer_usage() failed: %s (%d)",
619 strerror(-err), err);
620 surface->~Surface();
621 allocator->pfnFree(allocator->pUserData, surface);
Yiwei Zhang70a21962019-05-31 17:26:52 -0700622 return VK_ERROR_SURFACE_LOST_KHR;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700623 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700624
Yiwei Zhang6435b322018-05-08 11:12:17 -0700625 err =
Jesse Hall1356b0d2015-11-23 17:24:58 -0800626 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800627 if (err != android::OK) {
Jesse Hall1356b0d2015-11-23 17:24:58 -0800628 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
629 err);
630 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800631 allocator->pfnFree(allocator->pUserData, surface);
Mike Stroyan762c8132017-02-22 11:43:09 -0700632 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800633 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700634
Jesse Hall1356b0d2015-11-23 17:24:58 -0800635 *out_surface = HandleFromSurface(surface);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700636 return VK_SUCCESS;
637}
638
Jesse Halle1b12782015-11-30 11:27:32 -0800639VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800640void DestroySurfaceKHR(VkInstance instance,
641 VkSurfaceKHR surface_handle,
642 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800643 ATRACE_CALL();
644
Jesse Hall1356b0d2015-11-23 17:24:58 -0800645 Surface* surface = SurfaceFromHandle(surface_handle);
646 if (!surface)
647 return;
648 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700649 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
Jesse Halldc225072016-05-30 22:40:14 -0700650 "destroyed VkSurfaceKHR 0x%" PRIx64
651 " has active VkSwapchainKHR 0x%" PRIx64,
652 reinterpret_cast<uint64_t>(surface_handle),
653 reinterpret_cast<uint64_t>(surface->swapchain_handle));
Jesse Hall1356b0d2015-11-23 17:24:58 -0800654 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800655 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800656 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800657 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800658}
659
Jesse Halle1b12782015-11-30 11:27:32 -0800660VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800661VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
662 uint32_t /*queue_family*/,
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000663 VkSurfaceKHR /*surface_handle*/,
Chia-I Wu62262232016-03-26 07:06:44 +0800664 VkBool32* supported) {
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000665 *supported = VK_TRUE;
Jesse Halla6429252015-11-29 18:59:42 -0800666 return VK_SUCCESS;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800667}
668
Jesse Halle1b12782015-11-30 11:27:32 -0800669VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800670VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
Ian Elliott1ce053f2022-03-16 09:49:53 -0600671 VkPhysicalDevice pdev,
Jesse Hallb00daad2015-11-29 19:46:20 -0800672 VkSurfaceKHR surface,
673 VkSurfaceCapabilitiesKHR* capabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800674 ATRACE_CALL();
675
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000676 // Implement in terms of GetPhysicalDeviceSurfaceCapabilities2KHR
677
678 VkPhysicalDeviceSurfaceInfo2KHR info2 = {
679 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
680 nullptr,
681 surface
682 };
683
684 VkSurfaceCapabilities2KHR caps2 = {
685 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
686 nullptr,
687 {},
688 };
689
690 VkResult result = GetPhysicalDeviceSurfaceCapabilities2KHR(pdev, &info2, &caps2);
691 *capabilities = caps2.surfaceCapabilities;
692 return result;
693}
694
695// Does the call-twice and VK_INCOMPLETE handling for querying lists
696// of things, where we already have the full set built in a vector.
697template <typename T>
698VkResult CopyWithIncomplete(std::vector<T> const& things,
699 T* callerPtr, uint32_t* callerCount) {
700 VkResult result = VK_SUCCESS;
701 if (callerPtr) {
702 if (things.size() > *callerCount)
703 result = VK_INCOMPLETE;
704 *callerCount = std::min(uint32_t(things.size()), *callerCount);
705 std::copy(things.begin(), things.begin() + *callerCount, callerPtr);
Ian Elliott1ce053f2022-03-16 09:49:53 -0600706 } else {
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000707 *callerCount = things.size();
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800708 }
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000709 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700710}
711
Jesse Halle1b12782015-11-30 11:27:32 -0800712VKAPI_ATTR
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700713VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
714 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800715 uint32_t* count,
716 VkSurfaceFormatKHR* formats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800717 ATRACE_CALL();
718
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700719 const InstanceData& instance_data = GetData(pdev);
720
Ian Elliott1ce053f2022-03-16 09:49:53 -0600721 uint64_t consumer_usage = 0;
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000722 bool colorspace_ext =
Ian Elliottf6df08e2022-03-16 21:27:49 -0600723 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
Ian Elliott1ce053f2022-03-16 09:49:53 -0600724 if (surface_handle == VK_NULL_HANDLE) {
725 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
726 bool surfaceless_enabled =
727 instance_data.hook_extensions.test(surfaceless);
728 if (!surfaceless_enabled) {
729 return VK_ERROR_SURFACE_LOST_KHR;
730 }
Chris Forbesa9e28de2022-10-20 09:05:48 +1300731 // Support for VK_GOOGLE_surfaceless_query.
Ian Elliott1ce053f2022-03-16 09:49:53 -0600732
733 // TODO(b/203826952): research proper value; temporarily use the
734 // values seen on Pixel
735 consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY;
736 } else {
737 Surface& surface = *SurfaceFromHandle(surface_handle);
Ian Elliott1ce053f2022-03-16 09:49:53 -0600738 consumer_usage = surface.consumer_usage;
Ian Elliott6ba85d92022-02-18 16:44:58 -0700739 }
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700740
Charlie Lao324191f2019-12-13 11:03:16 -0800741 AHardwareBuffer_Desc desc = {};
742 desc.width = 1;
743 desc.height = 1;
744 desc.layers = 1;
Ian Elliott1ce053f2022-03-16 09:49:53 -0600745 desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
Charlie Lao324191f2019-12-13 11:03:16 -0800746 AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
747
748 // We must support R8G8B8A8
749 std::vector<VkSurfaceFormatKHR> all_formats = {
750 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Lingfeng Yange29191c2022-07-01 18:18:29 -0700751 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Lingfeng Yange29191c2022-07-01 18:18:29 -0700752 };
Charlie Lao324191f2019-12-13 11:03:16 -0800753
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000754 if (colorspace_ext) {
755 all_formats.emplace_back(VkSurfaceFormatKHR{
Jason Macnakca506332022-11-09 11:00:36 -0800756 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_PASS_THROUGH_EXT});
757 all_formats.emplace_back(VkSurfaceFormatKHR{
758 VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_PASS_THROUGH_EXT});
759 all_formats.emplace_back(VkSurfaceFormatKHR{
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000760 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800761 all_formats.emplace_back(VkSurfaceFormatKHR{
762 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
763 all_formats.emplace_back(VkSurfaceFormatKHR{
764 VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
765 }
766
Ian Elliott1ce053f2022-03-16 09:49:53 -0600767 // NOTE: Any new formats that are added must be coordinated across different
768 // Android users. This includes the ANGLE team (a layered implementation of
769 // OpenGL-ES).
770
Charlie Lao324191f2019-12-13 11:03:16 -0800771 desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
772 if (AHardwareBuffer_isSupported(&desc)) {
773 all_formats.emplace_back(VkSurfaceFormatKHR{
774 VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnakca506332022-11-09 11:00:36 -0800775 if (colorspace_ext) {
776 all_formats.emplace_back(
777 VkSurfaceFormatKHR{VK_FORMAT_R5G6B5_UNORM_PACK16,
778 VK_COLOR_SPACE_PASS_THROUGH_EXT});
779 }
Charlie Lao324191f2019-12-13 11:03:16 -0800780 }
781
782 desc.format = AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
783 if (AHardwareBuffer_isSupported(&desc)) {
784 all_formats.emplace_back(VkSurfaceFormatKHR{
785 VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnakca506332022-11-09 11:00:36 -0800786 if (colorspace_ext) {
787 all_formats.emplace_back(
788 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
789 VK_COLOR_SPACE_PASS_THROUGH_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800790 all_formats.emplace_back(
791 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
792 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT});
793 all_formats.emplace_back(
794 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
795 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT});
796 }
797 }
798
799 desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
800 if (AHardwareBuffer_isSupported(&desc)) {
801 all_formats.emplace_back(
802 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
803 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnakca506332022-11-09 11:00:36 -0800804 if (colorspace_ext) {
805 all_formats.emplace_back(
806 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
807 VK_COLOR_SPACE_PASS_THROUGH_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800808 all_formats.emplace_back(
809 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
810 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
811 }
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700812 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700813
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500814 desc.format = AHARDWAREBUFFER_FORMAT_R8_UNORM;
815 if (AHardwareBuffer_isSupported(&desc)) {
Jason Macnakca506332022-11-09 11:00:36 -0800816 if (colorspace_ext) {
817 all_formats.emplace_back(VkSurfaceFormatKHR{
818 VK_FORMAT_R8_UNORM, VK_COLOR_SPACE_PASS_THROUGH_EXT});
819 }
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500820 }
821
Trevor David Black67e9b102023-03-07 05:28:15 +0000822 bool rgba10x6_formats_ext = false;
823 uint32_t exts_count;
824 const auto& driver = GetData(pdev).driver;
825 driver.EnumerateDeviceExtensionProperties(pdev, nullptr, &exts_count,
826 nullptr);
827 std::vector<VkExtensionProperties> props(exts_count);
828 driver.EnumerateDeviceExtensionProperties(pdev, nullptr, &exts_count,
829 props.data());
830 for (uint32_t i = 0; i < exts_count; i++) {
831 VkExtensionProperties prop = props[i];
832 if (strcmp(prop.extensionName,
833 VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME) == 0) {
834 rgba10x6_formats_ext = true;
835 }
836 }
Trevor David Black9cfe1ed2022-12-05 20:04:57 +0000837 desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM;
Trevor David Black67e9b102023-03-07 05:28:15 +0000838 if (AHardwareBuffer_isSupported(&desc) && rgba10x6_formats_ext) {
Trevor David Black9cfe1ed2022-12-05 20:04:57 +0000839 all_formats.emplace_back(
840 VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
841 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
842 if (colorspace_ext) {
843 all_formats.emplace_back(
844 VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
845 VK_COLOR_SPACE_PASS_THROUGH_EXT});
846 all_formats.emplace_back(
847 VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
848 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
849 }
850 }
851
Ian Elliott6ba85d92022-02-18 16:44:58 -0700852 // NOTE: Any new formats that are added must be coordinated across different
853 // Android users. This includes the ANGLE team (a layered implementation of
854 // OpenGL-ES).
855
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000856 return CopyWithIncomplete(all_formats, formats, count);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700857}
858
Jesse Halle1b12782015-11-30 11:27:32 -0800859VKAPI_ATTR
Chris Forbes2452cf72017-03-16 16:30:17 +1300860VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
861 VkPhysicalDevice physicalDevice,
862 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
863 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800864 ATRACE_CALL();
865
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000866 auto surface = pSurfaceInfo->surface;
867 auto capabilities = &pSurfaceCapabilities->surfaceCapabilities;
Chris Forbes2452cf72017-03-16 16:30:17 +1300868
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000869 VkSurfacePresentModeEXT const *pPresentMode = nullptr;
870 for (auto pNext = reinterpret_cast<VkBaseInStructure const *>(pSurfaceInfo->pNext);
871 pNext; pNext = reinterpret_cast<VkBaseInStructure const *>(pNext->pNext)) {
872 switch (pNext->sType) {
873 case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
874 pPresentMode = reinterpret_cast<VkSurfacePresentModeEXT const *>(pNext);
875 break;
Chris Forbes06bc0092017-03-16 16:46:05 +1300876
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000877 default:
878 break;
879 }
880 }
881
882 int err;
883 int width, height;
884 int transform_hint;
885 int max_buffer_count;
Trevor David Black1d3509e2023-06-08 00:17:40 +0000886 int min_undequeued_buffers;
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000887 if (surface == VK_NULL_HANDLE) {
888 const InstanceData& instance_data = GetData(physicalDevice);
889 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
890 bool surfaceless_enabled =
891 instance_data.hook_extensions.test(surfaceless);
892 if (!surfaceless_enabled) {
893 // It is an error to pass a surface==VK_NULL_HANDLE unless the
894 // VK_GOOGLE_surfaceless_query extension is enabled
895 return VK_ERROR_SURFACE_LOST_KHR;
896 }
897 // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
898 // extension for this function is for
899 // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following
900 // four values cannot be known without a surface. Default values will
901 // be supplied anyway, but cannot be relied upon.
902 width = 0xFFFFFFFF;
903 height = 0xFFFFFFFF;
904 transform_hint = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
905 capabilities->minImageCount = 0xFFFFFFFF;
906 capabilities->maxImageCount = 0xFFFFFFFF;
907 } else {
908 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
909
910 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
911 if (err != android::OK) {
912 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
913 strerror(-err), err);
914 return VK_ERROR_SURFACE_LOST_KHR;
915 }
916 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
917 if (err != android::OK) {
918 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
919 strerror(-err), err);
920 return VK_ERROR_SURFACE_LOST_KHR;
921 }
922
923 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
924 &transform_hint);
925 if (err != android::OK) {
926 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
927 strerror(-err), err);
928 return VK_ERROR_SURFACE_LOST_KHR;
929 }
930
931 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT,
932 &max_buffer_count);
933 if (err != android::OK) {
934 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
935 strerror(-err), err);
936 return VK_ERROR_SURFACE_LOST_KHR;
937 }
938
Trevor David Black1d3509e2023-06-08 00:17:40 +0000939 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
940 &min_undequeued_buffers);
941 if (err != android::OK) {
942 ALOGE("NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d)",
943 strerror(-err), err);
944 return VK_ERROR_SURFACE_LOST_KHR;
945 }
946
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000947 if (pPresentMode && IsSharedPresentMode(pPresentMode->presentMode)) {
948 capabilities->minImageCount = 1;
949 capabilities->maxImageCount = 1;
950 } else if (pPresentMode && pPresentMode->presentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
Trevor David Black1d3509e2023-06-08 00:17:40 +0000951 capabilities->minImageCount =
952 std::min(max_buffer_count, min_undequeued_buffers + 2);
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000953 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
954 } else {
Trevor David Black1d3509e2023-06-08 00:17:40 +0000955 capabilities->minImageCount =
956 std::min(max_buffer_count, min_undequeued_buffers + 1);
Chris Forbes9d0d9ff2022-12-28 01:58:31 +0000957 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
958 }
959 }
960
961 capabilities->currentExtent =
962 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
963
964 // TODO(http://b/134182502): Figure out what the max extent should be.
965 capabilities->minImageExtent = VkExtent2D{1, 1};
966 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
967
968 if (capabilities->maxImageExtent.height <
969 capabilities->currentExtent.height) {
970 capabilities->maxImageExtent.height =
971 capabilities->currentExtent.height;
972 }
973
974 if (capabilities->maxImageExtent.width <
975 capabilities->currentExtent.width) {
976 capabilities->maxImageExtent.width = capabilities->currentExtent.width;
977 }
978
979 capabilities->maxImageArrayLayers = 1;
980
981 capabilities->supportedTransforms = kSupportedTransforms;
982 capabilities->currentTransform =
983 TranslateNativeToVulkanTransform(transform_hint);
984
985 // On Android, window composition is a WindowManager property, not something
986 // associated with the bufferqueue. It can't be changed from here.
987 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
988
989 capabilities->supportedUsageFlags =
990 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
991 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
992 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
993 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
994
995 for (auto pNext = reinterpret_cast<VkBaseOutStructure*>(pSurfaceCapabilities->pNext);
996 pNext; pNext = reinterpret_cast<VkBaseOutStructure*>(pNext->pNext)) {
997
998 switch (pNext->sType) {
Chris Forbes06bc0092017-03-16 16:46:05 +1300999 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
1000 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001001 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(pNext);
Chris Forbes06bc0092017-03-16 16:46:05 +13001002 // Claim same set of usage flags are supported for
1003 // shared present modes as for other modes.
1004 shared_caps->sharedPresentSupportedUsageFlags =
1005 pSurfaceCapabilities->surfaceCapabilities
1006 .supportedUsageFlags;
1007 } break;
1008
Ian Elliottbb67b242022-03-16 09:52:28 -06001009 case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
1010 VkSurfaceProtectedCapabilitiesKHR* protected_caps =
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001011 reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(pNext);
Ian Elliottbb67b242022-03-16 09:52:28 -06001012 protected_caps->supportsProtected = VK_TRUE;
1013 } break;
1014
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001015 case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
1016 VkSurfacePresentScalingCapabilitiesEXT* scaling_caps =
1017 reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(pNext);
1018 // By default, Android stretches the buffer to fit the window,
1019 // without preserving aspect ratio. Other modes are technically possible
1020 // but consult with CoGS team before exposing them here!
1021 scaling_caps->supportedPresentScaling = VK_PRESENT_SCALING_STRETCH_BIT_EXT;
1022
1023 // Since we always scale, we don't support any gravity.
1024 scaling_caps->supportedPresentGravityX = 0;
1025 scaling_caps->supportedPresentGravityY = 0;
1026
1027 // Scaled image limits are just the basic image limits
1028 scaling_caps->minScaledImageExtent = capabilities->minImageExtent;
1029 scaling_caps->maxScaledImageExtent = capabilities->maxImageExtent;
1030 } break;
1031
1032 case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
1033 VkSurfacePresentModeCompatibilityEXT* mode_caps =
1034 reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(pNext);
1035
1036 ALOG_ASSERT(pPresentMode,
1037 "querying VkSurfacePresentModeCompatibilityEXT "
1038 "requires VkSurfacePresentModeEXT to be provided");
1039 std::vector<VkPresentModeKHR> compatibleModes;
1040 compatibleModes.push_back(pPresentMode->presentMode);
1041
1042 switch (pPresentMode->presentMode) {
1043 // Shared modes are both compatible with each other.
1044 case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
1045 compatibleModes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
1046 break;
1047 case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
1048 compatibleModes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
1049 break;
1050 default:
1051 // Other modes are only compatible with themselves.
1052 // TODO: consider whether switching between FIFO and MAILBOX is reasonable
1053 break;
1054 }
1055
1056 // Note: this does not generate VK_INCOMPLETE since we're nested inside
1057 // a larger query and there would be no way to determine exactly where it came from.
1058 CopyWithIncomplete(compatibleModes, mode_caps->pPresentModes,
1059 &mode_caps->presentModeCount);
1060 } break;
1061
Chris Forbes06bc0092017-03-16 16:46:05 +13001062 default:
1063 // Ignore all other extension structs
1064 break;
1065 }
1066 }
1067
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001068 return VK_SUCCESS;
Chris Forbes2452cf72017-03-16 16:30:17 +13001069}
1070
1071VKAPI_ATTR
1072VkResult GetPhysicalDeviceSurfaceFormats2KHR(
1073 VkPhysicalDevice physicalDevice,
1074 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1075 uint32_t* pSurfaceFormatCount,
1076 VkSurfaceFormat2KHR* pSurfaceFormats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001077 ATRACE_CALL();
1078
Chris Forbes2452cf72017-03-16 16:30:17 +13001079 if (!pSurfaceFormats) {
1080 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
1081 pSurfaceInfo->surface,
1082 pSurfaceFormatCount, nullptr);
Trevor David Black929e9cd2022-11-22 04:12:19 +00001083 }
Chris Forbes2452cf72017-03-16 16:30:17 +13001084
Trevor David Black929e9cd2022-11-22 04:12:19 +00001085 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
1086 // after the call.
1087 std::vector<VkSurfaceFormatKHR> surface_formats(*pSurfaceFormatCount);
1088 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
1089 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
1090 surface_formats.data());
Trevor David Black2cc44682022-03-09 00:31:38 +00001091
Trevor David Black929e9cd2022-11-22 04:12:19 +00001092 if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
1093 return result;
1094 }
Trevor David Black2cc44682022-03-09 00:31:38 +00001095
Trevor David Black929e9cd2022-11-22 04:12:19 +00001096 const auto& driver = GetData(physicalDevice).driver;
1097
1098 // marshal results individually due to stride difference.
1099 uint32_t formats_to_marshal = *pSurfaceFormatCount;
1100 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
1101 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
1102
1103 // Query the compression properties for the surface format
1104 VkSurfaceFormat2KHR* pSurfaceFormat = &pSurfaceFormats[i];
1105 while (pSurfaceFormat->pNext) {
1106 pSurfaceFormat =
1107 reinterpret_cast<VkSurfaceFormat2KHR*>(pSurfaceFormat->pNext);
1108 switch (pSurfaceFormat->sType) {
1109 case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
Trevor David Black2cc44682022-03-09 00:31:38 +00001110 VkImageCompressionPropertiesEXT* surfaceCompressionProps =
1111 reinterpret_cast<VkImageCompressionPropertiesEXT*>(
Trevor David Black929e9cd2022-11-22 04:12:19 +00001112 pSurfaceFormat);
Trevor David Black2cc44682022-03-09 00:31:38 +00001113
1114 if (surfaceCompressionProps &&
1115 driver.GetPhysicalDeviceImageFormatProperties2KHR) {
1116 VkPhysicalDeviceImageFormatInfo2 imageFormatInfo = {};
1117 imageFormatInfo.sType =
1118 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
1119 imageFormatInfo.format =
1120 pSurfaceFormats[i].surfaceFormat.format;
1121 imageFormatInfo.pNext = nullptr;
1122
1123 VkImageCompressionControlEXT compressionControl = {};
1124 compressionControl.sType =
1125 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
1126 compressionControl.pNext = imageFormatInfo.pNext;
1127
1128 imageFormatInfo.pNext = &compressionControl;
1129
1130 VkImageCompressionPropertiesEXT compressionProps = {};
1131 compressionProps.sType =
1132 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
1133 compressionProps.pNext = nullptr;
1134
1135 VkImageFormatProperties2KHR imageFormatProps = {};
1136 imageFormatProps.sType =
1137 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR;
1138 imageFormatProps.pNext = &compressionProps;
1139
1140 VkResult compressionRes =
1141 driver.GetPhysicalDeviceImageFormatProperties2KHR(
1142 physicalDevice, &imageFormatInfo,
1143 &imageFormatProps);
1144 if (compressionRes == VK_SUCCESS) {
1145 surfaceCompressionProps->imageCompressionFlags =
1146 compressionProps.imageCompressionFlags;
1147 surfaceCompressionProps
1148 ->imageCompressionFixedRateFlags =
1149 compressionProps.imageCompressionFixedRateFlags;
1150 } else {
1151 return compressionRes;
1152 }
1153 }
Trevor David Black929e9cd2022-11-22 04:12:19 +00001154 } break;
1155
1156 default:
1157 // Ignore all other extension structs
1158 break;
Chris Forbes2452cf72017-03-16 16:30:17 +13001159 }
1160 }
Chris Forbes2452cf72017-03-16 16:30:17 +13001161 }
Trevor David Black929e9cd2022-11-22 04:12:19 +00001162
1163 return result;
Chris Forbes2452cf72017-03-16 16:30:17 +13001164}
1165
1166VKAPI_ATTR
Chris Forbese8d79a62017-02-22 12:49:18 +13001167VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
Yiwei Zhange4a559c2018-02-15 11:27:36 -08001168 VkSurfaceKHR surface,
Chia-I Wu62262232016-03-26 07:06:44 +08001169 uint32_t* count,
1170 VkPresentModeKHR* modes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001171 ATRACE_CALL();
1172
Yiwei Zhange4a559c2018-02-15 11:27:36 -08001173 int err;
1174 int query_value;
Ian Elliotte7f036c2022-03-15 16:49:21 -06001175 std::vector<VkPresentModeKHR> present_modes;
Ian Elliott1ce053f2022-03-16 09:49:53 -06001176 if (surface == VK_NULL_HANDLE) {
1177 const InstanceData& instance_data = GetData(pdev);
1178 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
1179 bool surfaceless_enabled =
1180 instance_data.hook_extensions.test(surfaceless);
1181 if (!surfaceless_enabled) {
1182 return VK_ERROR_SURFACE_LOST_KHR;
1183 }
1184 // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
1185 // extension for this function is for
1186 // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and
1187 // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot
1188 // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a
Ian Elliott7e361142022-06-02 10:45:17 -06001189 // surface, and that cannot be relied upon. Therefore, don't return it.
Ian Elliott1ce053f2022-03-16 09:49:53 -06001190 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
1191 } else {
1192 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
1193
1194 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
1195 &query_value);
1196 if (err != android::OK || query_value < 0) {
1197 ALOGE(
1198 "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) "
1199 "value=%d",
1200 strerror(-err), err, query_value);
1201 return VK_ERROR_SURFACE_LOST_KHR;
1202 }
1203 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
1204
1205 err =
1206 window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
1207 if (err != android::OK || query_value < 0) {
1208 ALOGE(
1209 "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
1210 strerror(-err), err, query_value);
1211 return VK_ERROR_SURFACE_LOST_KHR;
1212 }
1213 uint32_t max_buffer_count = static_cast<uint32_t>(query_value);
1214
1215 if (min_undequeued_buffers + 1 < max_buffer_count)
1216 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
1217 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
1218 }
Chris Forbese8d79a62017-02-22 12:49:18 +13001219
1220 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
Yiwei Zhang93b521c2020-07-11 16:32:09 -07001221 QueryPresentationProperties(pdev, &present_properties);
1222 if (present_properties.sharedImage) {
1223 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
1224 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
Chris Forbese8d79a62017-02-22 12:49:18 +13001225 }
1226
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001227 return CopyWithIncomplete(present_modes, modes, count);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001228}
1229
Jesse Halle1b12782015-11-30 11:27:32 -08001230VKAPI_ATTR
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001231VkResult GetDeviceGroupPresentCapabilitiesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -06001232 VkDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001233 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001234 ATRACE_CALL();
1235
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001236 ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
1237 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
1238 "vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
1239 "VkDeviceGroupPresentCapabilitiesKHR structure type %d",
1240 pDeviceGroupPresentCapabilities->sType);
1241
1242 memset(pDeviceGroupPresentCapabilities->presentMask, 0,
1243 sizeof(pDeviceGroupPresentCapabilities->presentMask));
1244
1245 // assume device group of size 1
1246 pDeviceGroupPresentCapabilities->presentMask[0] = 1 << 0;
1247 pDeviceGroupPresentCapabilities->modes =
1248 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
1249
1250 return VK_SUCCESS;
1251}
1252
1253VKAPI_ATTR
1254VkResult GetDeviceGroupSurfacePresentModesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -06001255 VkDevice,
1256 VkSurfaceKHR,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001257 VkDeviceGroupPresentModeFlagsKHR* pModes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001258 ATRACE_CALL();
1259
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001260 *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
1261 return VK_SUCCESS;
1262}
1263
1264VKAPI_ATTR
Ian Elliottcd8ad332017-10-13 09:21:12 -06001265VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001266 VkSurfaceKHR surface,
1267 uint32_t* pRectCount,
1268 VkRect2D* pRects) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001269 ATRACE_CALL();
1270
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001271 if (!pRects) {
1272 *pRectCount = 1;
1273 } else {
1274 uint32_t count = std::min(*pRectCount, 1u);
1275 bool incomplete = *pRectCount < 1;
1276
1277 *pRectCount = count;
1278
1279 if (incomplete) {
1280 return VK_INCOMPLETE;
1281 }
1282
1283 int err;
1284 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
1285
1286 int width = 0, height = 0;
1287 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001288 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001289 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
1290 strerror(-err), err);
1291 }
1292 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001293 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001294 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
1295 strerror(-err), err);
1296 }
1297
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001298 pRects[0].offset.x = 0;
1299 pRects[0].offset.y = 0;
1300 pRects[0].extent = VkExtent2D{static_cast<uint32_t>(width),
1301 static_cast<uint32_t>(height)};
1302 }
1303 return VK_SUCCESS;
1304}
1305
Yiwei Zhang533cea92019-06-03 18:43:24 -07001306static void DestroySwapchainInternal(VkDevice device,
1307 VkSwapchainKHR swapchain_handle,
1308 const VkAllocationCallbacks* allocator) {
1309 ATRACE_CALL();
1310
1311 const auto& dispatch = GetData(device).driver;
1312 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
1313 if (!swapchain) {
1314 return;
1315 }
1316
1317 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1318 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1319
1320 if (window && swapchain->frame_timestamps_enabled) {
1321 native_window_enable_frame_timestamps(window, false);
1322 }
1323
1324 for (uint32_t i = 0; i < swapchain->num_images; i++) {
Yiwei Zhangac1f0982022-04-09 07:10:10 +00001325 ReleaseSwapchainImage(device, swapchain->shared, window, -1,
1326 swapchain->images[i], false);
Yiwei Zhang533cea92019-06-03 18:43:24 -07001327 }
1328
1329 if (active) {
1330 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1331 }
1332
1333 if (!allocator) {
1334 allocator = &GetData(device).allocator;
1335 }
1336
1337 swapchain->~Swapchain();
1338 allocator->pfnFree(allocator->pUserData, swapchain);
1339}
1340
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001341VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001342VkResult CreateSwapchainKHR(VkDevice device,
1343 const VkSwapchainCreateInfoKHR* create_info,
1344 const VkAllocationCallbacks* allocator,
1345 VkSwapchainKHR* swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001346 ATRACE_CALL();
1347
Jesse Halld7b994a2015-09-07 14:17:37 -07001348 int err;
1349 VkResult result = VK_SUCCESS;
1350
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001351 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
1352 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
1353 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
1354 " oldSwapchain=0x%" PRIx64,
1355 reinterpret_cast<uint64_t>(create_info->surface),
1356 create_info->minImageCount, create_info->imageFormat,
1357 create_info->imageColorSpace, create_info->imageExtent.width,
1358 create_info->imageExtent.height, create_info->imageUsage,
1359 create_info->preTransform, create_info->presentMode,
1360 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1361
Jesse Hall1f91d392015-12-11 16:28:44 -08001362 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001363 allocator = &GetData(device).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -08001364
Trevor David Blackf499b5a2023-07-14 17:30:41 +00001365 PixelFormat native_pixel_format =
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001366 GetNativePixelFormat(create_info->imageFormat);
1367 android_dataspace native_dataspace =
Sally Qi03a1a752023-07-17 12:52:05 +08001368 GetNativeDataspace(create_info->imageColorSpace, native_pixel_format);
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001369 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
1370 ALOGE(
1371 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
1372 "failed: Unsupported color space",
1373 create_info->imageColorSpace);
1374 return VK_ERROR_INITIALIZATION_FAILED;
1375 }
1376
Jesse Hall42a9eec2016-06-03 12:39:49 -07001377 ALOGV_IF(create_info->imageArrayLayers != 1,
Jesse Halldc225072016-05-30 22:40:14 -07001378 "swapchain imageArrayLayers=%u not supported",
Jesse Hall715b86a2016-01-16 16:34:29 -08001379 create_info->imageArrayLayers);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001380 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
Jesse Halldc225072016-05-30 22:40:14 -07001381 "swapchain preTransform=%#x not supported",
Jesse Hall55bc0972016-02-23 16:43:29 -08001382 create_info->preTransform);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001383 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
Chris Forbes980ad052017-01-18 16:55:07 +13001384 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
Chris Forbes1d5f68c2017-01-31 10:17:01 +13001385 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1386 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
Jesse Halldc225072016-05-30 22:40:14 -07001387 "swapchain presentMode=%u not supported",
Jesse Hall0ae0dce2016-02-09 22:13:34 -08001388 create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -07001389
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001390 Surface& surface = *SurfaceFromHandle(create_info->surface);
1391
Jesse Halldc225072016-05-30 22:40:14 -07001392 if (surface.swapchain_handle != create_info->oldSwapchain) {
Jesse Hall42a9eec2016-06-03 12:39:49 -07001393 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
Jesse Halldc225072016-05-30 22:40:14 -07001394 " because it already has active swapchain 0x%" PRIx64
1395 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
1396 reinterpret_cast<uint64_t>(create_info->surface),
1397 reinterpret_cast<uint64_t>(surface.swapchain_handle),
1398 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1399 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
1400 }
1401 if (create_info->oldSwapchain != VK_NULL_HANDLE)
1402 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
1403
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001404 // -- Reset the native window --
1405 // The native window might have been used previously, and had its properties
1406 // changed from defaults. That will affect the answer we get for queries
1407 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
1408 // attempt such queries.
1409
Jesse Halldc225072016-05-30 22:40:14 -07001410 // The native window only allows dequeueing all buffers before any have
1411 // been queued, since after that point at least one is assumed to be in
1412 // non-FREE state at any given time. Disconnecting and re-connecting
1413 // orphans the previous buffers, getting us back to the state where we can
1414 // dequeue all buffers.
Yiwei Zhang70a21962019-05-31 17:26:52 -07001415 //
Yiwei Zhang3b88f312023-04-18 23:11:35 +00001416 // This is not necessary if the surface was never used previously.
1417 //
Yiwei Zhang70a21962019-05-31 17:26:52 -07001418 // TODO(http://b/134186185) recycle swapchain images more efficiently
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001419 ANativeWindow* window = surface.window.get();
Yiwei Zhang3b88f312023-04-18 23:11:35 +00001420 if (surface.used_by_swapchain) {
1421 err = native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
1422 ALOGW_IF(err != android::OK,
1423 "native_window_api_disconnect failed: %s (%d)", strerror(-err),
1424 err);
1425 err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
1426 ALOGW_IF(err != android::OK,
1427 "native_window_api_connect failed: %s (%d)", strerror(-err),
1428 err);
1429 }
Jesse Halldc225072016-05-30 22:40:14 -07001430
Nicolas Capens147b7da2021-04-09 14:53:06 -04001431 err =
1432 window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, nsecs_t{-1});
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001433 if (err != android::OK) {
1434 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1435 strerror(-err), err);
1436 return VK_ERROR_SURFACE_LOST_KHR;
1437 }
1438
Hrishikesh Manohar9b7e4532017-01-10 17:52:11 +05301439 int swap_interval =
1440 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001441 err = window->setSwapInterval(window, swap_interval);
1442 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001443 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
1444 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001445 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001446 }
1447
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001448 err = native_window_set_shared_buffer_mode(window, false);
1449 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001450 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
1451 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001452 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001453 }
1454
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001455 err = native_window_set_auto_refresh(window, false);
1456 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001457 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
1458 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001459 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001460 }
1461
Jesse Halld7b994a2015-09-07 14:17:37 -07001462 // -- Configure the native window --
Jesse Halld7b994a2015-09-07 14:17:37 -07001463
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001464 const auto& dispatch = GetData(device).driver;
Jesse Hall70f93352015-11-04 09:41:31 -08001465
Trevor David Blackf499b5a2023-07-14 17:30:41 +00001466 err = native_window_set_buffers_format(
1467 window, static_cast<int>(native_pixel_format));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001468 if (err != android::OK) {
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -05001469 ALOGE("native_window_set_buffers_format(%s) failed: %s (%d)",
Trevor David Blackf499b5a2023-07-14 17:30:41 +00001470 toString(native_pixel_format).c_str(), strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001471 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001472 }
Yiwei Zhang51572c22022-07-22 23:08:30 +00001473
1474 /* Respect consumer default dataspace upon HAL_DATASPACE_ARBITRARY. */
1475 if (native_dataspace != HAL_DATASPACE_ARBITRARY) {
1476 err = native_window_set_buffers_data_space(window, native_dataspace);
1477 if (err != android::OK) {
1478 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
1479 native_dataspace, strerror(-err), err);
1480 return VK_ERROR_SURFACE_LOST_KHR;
1481 }
Jesse Hall517274a2016-02-10 00:07:18 -08001482 }
1483
Jesse Hall3dd678a2016-01-08 21:52:01 -08001484 err = native_window_set_buffers_dimensions(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001485 window, static_cast<int>(create_info->imageExtent.width),
Jesse Hall3dd678a2016-01-08 21:52:01 -08001486 static_cast<int>(create_info->imageExtent.height));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001487 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001488 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
1489 create_info->imageExtent.width, create_info->imageExtent.height,
1490 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001491 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001492 }
1493
Jesse Hall178b6962016-02-24 15:39:50 -08001494 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
1495 // applied during rendering. native_window_set_transform() expects the
1496 // inverse: the transform the app is requesting that the compositor perform
1497 // during composition. With native windows, pre-transform works by rendering
1498 // with the same transform the compositor is applying (as in Vulkan), but
1499 // then requesting the inverse transform, so that when the compositor does
1500 // it's job the two transforms cancel each other out and the compositor ends
1501 // up applying an identity transform to the app's buffer.
1502 err = native_window_set_buffers_transform(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001503 window, InvertTransformToNative(create_info->preTransform));
1504 if (err != android::OK) {
Jesse Hall178b6962016-02-24 15:39:50 -08001505 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
1506 InvertTransformToNative(create_info->preTransform),
1507 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001508 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall178b6962016-02-24 15:39:50 -08001509 }
1510
Jesse Hallf64ca122015-11-03 16:11:10 -08001511 err = native_window_set_scaling_mode(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001512 window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
1513 if (err != android::OK) {
Jesse Hallf64ca122015-11-03 16:11:10 -08001514 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
1515 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001516 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hallf64ca122015-11-03 16:11:10 -08001517 }
1518
Chris Forbes97ef4612017-03-30 19:37:50 +13001519 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001520 if (IsSharedPresentMode(create_info->presentMode)) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001521 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001522 err = native_window_set_shared_buffer_mode(window, true);
1523 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001524 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
1525 return VK_ERROR_SURFACE_LOST_KHR;
1526 }
1527 }
1528
1529 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001530 err = native_window_set_auto_refresh(window, true);
1531 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001532 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
1533 return VK_ERROR_SURFACE_LOST_KHR;
1534 }
1535 }
1536
Ian Elliott16c443c2021-11-30 17:10:32 -07001537 int query_value;
1538 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
1539 &query_value);
1540 if (err != android::OK || query_value < 0) {
1541 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
1542 query_value);
Mike Stroyan762c8132017-02-22 11:43:09 -07001543 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001544 }
Ian Elliott16c443c2021-11-30 17:10:32 -07001545 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
1546 const auto mailbox_num_images = std::max(3u, create_info->minImageCount);
1547 const auto requested_images =
1548 swap_interval ? create_info->minImageCount : mailbox_num_images;
1549 uint32_t num_images = requested_images - 1 + min_undequeued_buffers;
Chris Forbes2c8fc752017-03-17 11:28:32 +13001550
Ian Elliott5396b702021-12-13 19:32:34 -07001551 // Lower layer insists that we have at least min_undequeued_buffers + 1
1552 // buffers. This is wasteful and we'd like to relax it in the shared case,
1553 // but not all the pieces are in place for that to work yet. Note we only
1554 // lie to the lower layer--we don't want to give the app back a swapchain
1555 // with extra images (which they can't actually use!).
1556 uint32_t min_buffer_count = min_undequeued_buffers + 1;
1557 err = native_window_set_buffer_count(
1558 window, std::max(min_buffer_count, num_images));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001559 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001560 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
1561 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001562 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001563 }
1564
Ian Elliott12b7e2f2021-12-21 23:24:20 -07001565 // In shared mode the num_images must be one regardless of how many
1566 // buffers were allocated for the buffer queue.
1567 if (swapchain_image_usage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) {
1568 num_images = 1;
1569 }
1570
Trevor David Black2cc44682022-03-09 00:31:38 +00001571 void* usage_info_pNext = nullptr;
1572 VkImageCompressionControlEXT image_compression = {};
John Reck97678d42022-08-23 11:24:51 -04001573 uint64_t native_usage = 0;
Trevor David Black2cc44682022-03-09 00:31:38 +00001574 if (dispatch.GetSwapchainGrallocUsage3ANDROID) {
1575 ATRACE_BEGIN("GetSwapchainGrallocUsage3ANDROID");
1576 VkGrallocUsageInfoANDROID gralloc_usage_info = {};
1577 gralloc_usage_info.sType = VK_STRUCTURE_TYPE_GRALLOC_USAGE_INFO_ANDROID;
1578 gralloc_usage_info.format = create_info->imageFormat;
1579 gralloc_usage_info.imageUsage = create_info->imageUsage;
1580
1581 // Look through the pNext chain for an image compression control struct
1582 // if one is found AND the appropriate extensions are enabled,
1583 // append it to be the gralloc usage pNext chain
1584 const VkSwapchainCreateInfoKHR* create_infos = create_info;
1585 while (create_infos->pNext) {
1586 create_infos = reinterpret_cast<const VkSwapchainCreateInfoKHR*>(
1587 create_infos->pNext);
1588 switch (create_infos->sType) {
1589 case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
1590 const VkImageCompressionControlEXT* compression_infos =
1591 reinterpret_cast<const VkImageCompressionControlEXT*>(
1592 create_infos);
1593 image_compression = *compression_infos;
1594 image_compression.pNext = nullptr;
1595 usage_info_pNext = &image_compression;
1596 } break;
1597
1598 default:
1599 // Ignore all other info structs
1600 break;
1601 }
1602 }
1603 gralloc_usage_info.pNext = usage_info_pNext;
1604
1605 result = dispatch.GetSwapchainGrallocUsage3ANDROID(
1606 device, &gralloc_usage_info, &native_usage);
1607 ATRACE_END();
1608 if (result != VK_SUCCESS) {
1609 ALOGE("vkGetSwapchainGrallocUsage3ANDROID failed: %d", result);
1610 return VK_ERROR_SURFACE_LOST_KHR;
1611 }
1612 } else if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
Jesse Halld1abd742017-02-09 21:45:51 -08001613 uint64_t consumer_usage, producer_usage;
Yiwei Zhang533cea92019-06-03 18:43:24 -07001614 ATRACE_BEGIN("GetSwapchainGrallocUsage2ANDROID");
Courtney Goeltzenleuchter894780b2017-04-03 16:11:30 -06001615 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1616 device, create_info->imageFormat, create_info->imageUsage,
1617 swapchain_image_usage, &consumer_usage, &producer_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001618 ATRACE_END();
Chris Forbes8c47dc92017-01-12 11:13:58 +13001619 if (result != VK_SUCCESS) {
1620 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001621 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001622 }
John Reck97678d42022-08-23 11:24:51 -04001623 native_usage =
Trevor David Black2cc44682022-03-09 00:31:38 +00001624 convertGralloc1ToBufferUsage(producer_usage, consumer_usage);
Chris Forbes8c47dc92017-01-12 11:13:58 +13001625 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001626 ATRACE_BEGIN("GetSwapchainGrallocUsageANDROID");
John Reck97678d42022-08-23 11:24:51 -04001627 int32_t legacy_usage = 0;
Jesse Hall1f91d392015-12-11 16:28:44 -08001628 result = dispatch.GetSwapchainGrallocUsageANDROID(
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001629 device, create_info->imageFormat, create_info->imageUsage,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001630 &legacy_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001631 ATRACE_END();
Jesse Hall70f93352015-11-04 09:41:31 -08001632 if (result != VK_SUCCESS) {
1633 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001634 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001635 }
John Reck97678d42022-08-23 11:24:51 -04001636 native_usage = static_cast<uint64_t>(legacy_usage);
Jesse Hall70f93352015-11-04 09:41:31 -08001637 }
John Reck97678d42022-08-23 11:24:51 -04001638 native_usage |= surface.consumer_usage;
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001639
1640 bool createProtectedSwapchain = false;
1641 if (create_info->flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
1642 createProtectedSwapchain = true;
1643 native_usage |= BufferUsage::PROTECTED;
1644 }
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001645 err = native_window_set_usage(window, native_usage);
1646 if (err != android::OK) {
Jesse Hall70f93352015-11-04 09:41:31 -08001647 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001648 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001649 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001650
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001651 int transform_hint;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001652 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
1653 if (err != android::OK) {
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001654 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1655 strerror(-err), err);
1656 return VK_ERROR_SURFACE_LOST_KHR;
1657 }
1658
Alina Kalyakina3d6f3632023-03-22 17:13:47 +00001659 int64_t refresh_duration;
1660 err = native_window_get_refresh_cycle_duration(window, &refresh_duration);
1661 if (err != android::OK) {
1662 ALOGE("native_window_get_refresh_cycle_duration query failed: %s (%d)",
1663 strerror(-err), err);
1664 return VK_ERROR_SURFACE_LOST_KHR;
1665 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001666 // -- Allocate our Swapchain object --
1667 // After this point, we must deallocate the swapchain on error.
1668
Jesse Hall1f91d392015-12-11 16:28:44 -08001669 void* mem = allocator->pfnAllocation(allocator->pUserData,
1670 sizeof(Swapchain), alignof(Swapchain),
1671 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001672 if (!mem)
Jesse Halld7b994a2015-09-07 14:17:37 -07001673 return VK_ERROR_OUT_OF_HOST_MEMORY;
silence_dogood73597592019-05-23 16:57:37 -07001674 Swapchain* swapchain = new (mem)
1675 Swapchain(surface, num_images, create_info->presentMode,
Alina Kalyakina3d6f3632023-03-22 17:13:47 +00001676 TranslateVulkanToNativeTransform(create_info->preTransform),
1677 refresh_duration);
Chris Forbesb56287a2017-01-12 14:28:58 +13001678 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1679#pragma clang diagnostic push
1680#pragma clang diagnostic ignored "-Wold-style-cast"
1681 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1682#pragma clang diagnostic pop
Trevor David Black2cc44682022-03-09 00:31:38 +00001683 .pNext = usage_info_pNext,
Chris Forbesb56287a2017-01-12 14:28:58 +13001684 .usage = swapchain_image_usage,
1685 };
Jesse Halld7b994a2015-09-07 14:17:37 -07001686 VkNativeBufferANDROID image_native_buffer = {
Jesse Halld7b994a2015-09-07 14:17:37 -07001687#pragma clang diagnostic push
1688#pragma clang diagnostic ignored "-Wold-style-cast"
1689 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1690#pragma clang diagnostic pop
Chris Forbesb56287a2017-01-12 14:28:58 +13001691 .pNext = &swapchain_image_create,
Jesse Halld7b994a2015-09-07 14:17:37 -07001692 };
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001693
Jesse Halld7b994a2015-09-07 14:17:37 -07001694 VkImageCreateInfo image_create = {
1695 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001696 .pNext = nullptr,
Nick Desaulnierse745a3e2019-10-18 10:38:45 -07001697 .flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
Jesse Halld7b994a2015-09-07 14:17:37 -07001698 .imageType = VK_IMAGE_TYPE_2D,
Jesse Hall517274a2016-02-10 00:07:18 -08001699 .format = create_info->imageFormat,
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001700 .extent = {
1701 create_info->imageExtent.width,
1702 create_info->imageExtent.height,
1703 1
1704 },
Jesse Halld7b994a2015-09-07 14:17:37 -07001705 .mipLevels = 1,
Jesse Halla15a4bf2015-11-19 22:48:02 -08001706 .arrayLayers = 1,
Jesse Hall091ed9e2015-11-30 00:55:29 -08001707 .samples = VK_SAMPLE_COUNT_1_BIT,
Jesse Halld7b994a2015-09-07 14:17:37 -07001708 .tiling = VK_IMAGE_TILING_OPTIMAL,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001709 .usage = create_info->imageUsage,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001710 .sharingMode = create_info->imageSharingMode,
Jesse Hall03b6fe12015-11-24 12:44:21 -08001711 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
Jesse Halld7b994a2015-09-07 14:17:37 -07001712 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1713 };
1714
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001715 // Note: don't do deferred allocation for shared present modes. There's only one buffer
1716 // involved so very little benefit.
1717 if ((create_info->flags & VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT) &&
1718 !IsSharedPresentMode(create_info->presentMode)) {
1719 // Don't want to touch the underlying gralloc buffers yet;
1720 // instead just create unbound VkImages which will later be bound to memory inside
1721 // AcquireNextImage.
1722 VkImageSwapchainCreateInfoKHR image_swapchain_create = {
1723 .sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
1724 .pNext = nullptr,
1725 .swapchain = HandleFromSwapchain(swapchain),
1726 };
1727 image_create.pNext = &image_swapchain_create;
Jesse Halld7b994a2015-09-07 14:17:37 -07001728
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001729 for (uint32_t i = 0; i < num_images; i++) {
1730 Swapchain::Image& img = swapchain->images[i];
1731 img.buffer = nullptr;
1732 img.dequeued = false;
1733
1734 result = dispatch.CreateImage(device, &image_create, nullptr, &img.image);
1735 if (result != VK_SUCCESS) {
1736 ALOGD("vkCreateImage w/ for deferred swapchain image failed: %u", result);
1737 break;
Yiwei Zhang702beb42019-11-29 17:59:55 -08001738 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001739 }
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001740 } else {
1741 // -- Dequeue all buffers and create a VkImage for each --
1742 // Any failures during or after this must cancel the dequeued buffers.
Jesse Halld7b994a2015-09-07 14:17:37 -07001743
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001744 for (uint32_t i = 0; i < num_images; i++) {
1745 Swapchain::Image& img = swapchain->images[i];
Jesse Halld7b994a2015-09-07 14:17:37 -07001746
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001747 ANativeWindowBuffer* buffer;
1748 err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
1749 if (err != android::OK) {
1750 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
1751 switch (-err) {
1752 case ENOMEM:
1753 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
1754 break;
1755 default:
1756 result = VK_ERROR_SURFACE_LOST_KHR;
1757 break;
1758 }
1759 break;
1760 }
1761 img.buffer = buffer;
1762 img.dequeued = true;
1763
1764 image_native_buffer.handle = img.buffer->handle;
1765 image_native_buffer.stride = img.buffer->stride;
1766 image_native_buffer.format = img.buffer->format;
1767 image_native_buffer.usage = int(img.buffer->usage);
1768 android_convertGralloc0To1Usage(int(img.buffer->usage),
1769 &image_native_buffer.usage2.producer,
1770 &image_native_buffer.usage2.consumer);
1771 image_native_buffer.usage3 = img.buffer->usage;
1772 image_create.pNext = &image_native_buffer;
1773
1774 ATRACE_BEGIN("CreateImage");
1775 result =
1776 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
1777 ATRACE_END();
1778 if (result != VK_SUCCESS) {
1779 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1780 break;
1781 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001782 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001783
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001784 // -- Cancel all buffers, returning them to the queue --
1785 // If an error occurred before, also destroy the VkImage and release the
1786 // buffer reference. Otherwise, we retain a strong reference to the buffer.
1787 for (uint32_t i = 0; i < num_images; i++) {
1788 Swapchain::Image& img = swapchain->images[i];
1789 if (img.dequeued) {
1790 if (!swapchain->shared) {
1791 window->cancelBuffer(window, img.buffer.get(),
1792 img.dequeue_fence);
1793 img.dequeue_fence = -1;
1794 img.dequeued = false;
1795 }
Chris Forbese0ced032017-03-30 19:44:15 +13001796 }
Chris Forbes31b85c22018-05-29 15:03:28 -07001797 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001798 }
1799
1800 if (result != VK_SUCCESS) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001801 DestroySwapchainInternal(device, HandleFromSwapchain(swapchain),
1802 allocator);
Jesse Halld7b994a2015-09-07 14:17:37 -07001803 return result;
1804 }
1805
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001806 if (transform_hint != swapchain->pre_transform) {
1807 // Log that the app is not doing pre-rotation.
1808 android::GraphicsEnv::getInstance().setTargetStats(
1809 android::GpuStatsInfo::Stats::FALSE_PREROTATION);
1810 }
1811
Serdar Kocdemirb2901c92022-11-17 00:39:05 +00001812 // Set stats for creating a Vulkan swapchain
1813 android::GraphicsEnv::getInstance().setTargetStats(
1814 android::GpuStatsInfo::Stats::CREATED_VULKAN_SWAPCHAIN);
1815
Yiwei Zhang3b88f312023-04-18 23:11:35 +00001816 surface.used_by_swapchain = true;
Jesse Halldc225072016-05-30 22:40:14 -07001817 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1818 *swapchain_handle = surface.swapchain_handle;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001819 return VK_SUCCESS;
1820}
1821
Jesse Halle1b12782015-11-30 11:27:32 -08001822VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001823void DestroySwapchainKHR(VkDevice device,
1824 VkSwapchainKHR swapchain_handle,
1825 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001826 ATRACE_CALL();
1827
Yiwei Zhang533cea92019-06-03 18:43:24 -07001828 DestroySwapchainInternal(device, swapchain_handle, allocator);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001829}
1830
Jesse Halle1b12782015-11-30 11:27:32 -08001831VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001832VkResult GetSwapchainImagesKHR(VkDevice,
1833 VkSwapchainKHR swapchain_handle,
1834 uint32_t* count,
1835 VkImage* images) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001836 ATRACE_CALL();
1837
Jesse Halld7b994a2015-09-07 14:17:37 -07001838 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Halldc225072016-05-30 22:40:14 -07001839 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1840 "getting images for non-active swapchain 0x%" PRIx64
1841 "; only dequeued image handles are valid",
1842 reinterpret_cast<uint64_t>(swapchain_handle));
Jesse Halld7b994a2015-09-07 14:17:37 -07001843 VkResult result = VK_SUCCESS;
1844 if (images) {
1845 uint32_t n = swapchain.num_images;
1846 if (*count < swapchain.num_images) {
1847 n = *count;
1848 result = VK_INCOMPLETE;
1849 }
1850 for (uint32_t i = 0; i < n; i++)
1851 images[i] = swapchain.images[i].image;
Jesse Hall7331e222016-09-15 21:26:01 -07001852 *count = n;
1853 } else {
1854 *count = swapchain.num_images;
Jesse Halld7b994a2015-09-07 14:17:37 -07001855 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001856 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001857}
1858
Jesse Halle1b12782015-11-30 11:27:32 -08001859VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001860VkResult AcquireNextImageKHR(VkDevice device,
1861 VkSwapchainKHR swapchain_handle,
1862 uint64_t timeout,
1863 VkSemaphore semaphore,
1864 VkFence vk_fence,
1865 uint32_t* image_index) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001866 ATRACE_CALL();
1867
Jesse Halld7b994a2015-09-07 14:17:37 -07001868 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001869 ANativeWindow* window = swapchain.surface.window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -07001870 VkResult result;
1871 int err;
1872
Jesse Halldc225072016-05-30 22:40:14 -07001873 if (swapchain.surface.swapchain_handle != swapchain_handle)
1874 return VK_ERROR_OUT_OF_DATE_KHR;
1875
Chris Forbesc88409c2017-03-30 19:47:37 +13001876 if (swapchain.shared) {
1877 // In shared mode, we keep the buffer dequeued all the time, so we don't
1878 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1879 // the semaphore and fence passed to us will be signalled.
1880 *image_index = 0;
1881 result = GetData(device).driver.AcquireImageANDROID(
1882 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1883 return result;
1884 }
1885
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001886 const nsecs_t acquire_next_image_timeout =
1887 timeout > (uint64_t)std::numeric_limits<nsecs_t>::max() ? -1 : timeout;
1888 if (acquire_next_image_timeout != swapchain.acquire_next_image_timeout) {
1889 // Cache the timeout to avoid the duplicate binder cost.
1890 err = window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT,
1891 acquire_next_image_timeout);
1892 if (err != android::OK) {
1893 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1894 strerror(-err), err);
1895 return VK_ERROR_SURFACE_LOST_KHR;
1896 }
1897 swapchain.acquire_next_image_timeout = acquire_next_image_timeout;
1898 }
1899
Jesse Halld7b994a2015-09-07 14:17:37 -07001900 ANativeWindowBuffer* buffer;
Jesse Hall06193802015-12-03 16:12:51 -08001901 int fence_fd;
1902 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Yiwei Zhangc0f8a2c2020-04-30 20:23:13 -07001903 if (err == android::TIMED_OUT || err == android::INVALID_OPERATION) {
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001904 ALOGW("dequeueBuffer timed out: %s (%d)", strerror(-err), err);
1905 return timeout ? VK_TIMEOUT : VK_NOT_READY;
1906 } else if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001907 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001908 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001909 }
1910
1911 uint32_t idx;
1912 for (idx = 0; idx < swapchain.num_images; idx++) {
1913 if (swapchain.images[idx].buffer.get() == buffer) {
1914 swapchain.images[idx].dequeued = true;
Jesse Hall06193802015-12-03 16:12:51 -08001915 swapchain.images[idx].dequeue_fence = fence_fd;
Jesse Halld7b994a2015-09-07 14:17:37 -07001916 break;
1917 }
1918 }
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00001919
1920 // If this is a deferred alloc swapchain, this may be the first time we've
1921 // seen a particular buffer. If so, there should be an empty slot. Find it,
1922 // and bind the gralloc buffer to the VkImage for that slot. If there is no
1923 // empty slot, then we dequeued an unexpected buffer. Non-deferred swapchains
1924 // will also take this path, but will never have an empty slot since we
1925 // populated them all upfront.
1926 if (idx == swapchain.num_images) {
1927 for (idx = 0; idx < swapchain.num_images; idx++) {
1928 if (!swapchain.images[idx].buffer) {
1929 // Note: this structure is technically required for
1930 // Vulkan correctness, even though the driver is probably going
1931 // to use everything from the VkNativeBufferANDROID below.
1932 // This is kindof silly, but it's how we did the ANB
1933 // side of VK_KHR_swapchain v69, so we're stuck with it unless
1934 // we want to go tinkering with the ANB spec some more.
1935 VkBindImageMemorySwapchainInfoKHR bimsi = {
1936 .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
1937 .pNext = nullptr,
1938 .swapchain = swapchain_handle,
1939 .imageIndex = idx,
1940 };
1941 VkNativeBufferANDROID nb = {
1942 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1943 .pNext = &bimsi,
1944 .handle = buffer->handle,
1945 .stride = buffer->stride,
1946 .format = buffer->format,
1947 .usage = int(buffer->usage),
1948 };
1949 VkBindImageMemoryInfo bimi = {
1950 .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
1951 .pNext = &nb,
1952 .image = swapchain.images[idx].image,
1953 .memory = VK_NULL_HANDLE,
1954 .memoryOffset = 0,
1955 };
1956 result = GetData(device).driver.BindImageMemory2(device, 1, &bimi);
1957 if (result != VK_SUCCESS) {
1958 // This shouldn't really happen. If it does, something is probably
1959 // unrecoverably wrong with the swapchain and its images. Cancel
1960 // the buffer and declare the swapchain broken.
1961 ALOGE("failed to do deferred gralloc buffer bind");
1962 window->cancelBuffer(window, buffer, fence_fd);
1963 return VK_ERROR_OUT_OF_DATE_KHR;
1964 }
1965
1966 swapchain.images[idx].dequeued = true;
1967 swapchain.images[idx].dequeue_fence = fence_fd;
1968 swapchain.images[idx].buffer = buffer;
1969 break;
1970 }
1971 }
1972 }
1973
1974 // The buffer doesn't match any slot. This shouldn't normally happen, but is
1975 // possible if the bufferqueue is reconfigured behind libvulkan's back. If this
1976 // happens, just declare the swapchain to be broken and the app will recreate it.
Jesse Halld7b994a2015-09-07 14:17:37 -07001977 if (idx == swapchain.num_images) {
1978 ALOGE("dequeueBuffer returned unrecognized buffer");
Jesse Hall06193802015-12-03 16:12:51 -08001979 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001980 return VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001981 }
1982
1983 int fence_clone = -1;
Jesse Hall06193802015-12-03 16:12:51 -08001984 if (fence_fd != -1) {
1985 fence_clone = dup(fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001986 if (fence_clone == -1) {
1987 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1988 strerror(errno), errno);
Jesse Hall06193802015-12-03 16:12:51 -08001989 sync_wait(fence_fd, -1 /* forever */);
Jesse Halld7b994a2015-09-07 14:17:37 -07001990 }
1991 }
1992
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001993 result = GetData(device).driver.AcquireImageANDROID(
Jesse Hall1f91d392015-12-11 16:28:44 -08001994 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001995 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001996 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1997 // even if the call fails. We could close it ourselves on failure, but
1998 // that would create a race condition if the driver closes it on a
1999 // failure path: some other thread might create an fd with the same
2000 // number between the time the driver closes it and the time we close
2001 // it. We must assume one of: the driver *always* closes it even on
2002 // failure, or *never* closes it on failure.
Jesse Hall06193802015-12-03 16:12:51 -08002003 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07002004 swapchain.images[idx].dequeued = false;
2005 swapchain.images[idx].dequeue_fence = -1;
2006 return result;
2007 }
2008
2009 *image_index = idx;
Jesse Hallb1352bc2015-09-04 16:12:33 -07002010 return VK_SUCCESS;
2011}
2012
Daniel Kochf25f5bb2017-10-05 00:26:58 -04002013VKAPI_ATTR
2014VkResult AcquireNextImage2KHR(VkDevice device,
2015 const VkAcquireNextImageInfoKHR* pAcquireInfo,
2016 uint32_t* pImageIndex) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002017 ATRACE_CALL();
2018
Daniel Kochf25f5bb2017-10-05 00:26:58 -04002019 return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
2020 pAcquireInfo->timeout, pAcquireInfo->semaphore,
2021 pAcquireInfo->fence, pImageIndex);
2022}
2023
Jesse Halldc225072016-05-30 22:40:14 -07002024static VkResult WorstPresentResult(VkResult a, VkResult b) {
2025 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
2026 // (in spec version 1.0.14).
2027 static const VkResult kWorstToBest[] = {
2028 VK_ERROR_DEVICE_LOST,
2029 VK_ERROR_SURFACE_LOST_KHR,
2030 VK_ERROR_OUT_OF_DATE_KHR,
2031 VK_ERROR_OUT_OF_DEVICE_MEMORY,
2032 VK_ERROR_OUT_OF_HOST_MEMORY,
2033 VK_SUBOPTIMAL_KHR,
2034 };
2035 for (auto result : kWorstToBest) {
2036 if (a == result || b == result)
2037 return result;
2038 }
2039 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
2040 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
2041 return a != VK_SUCCESS ? a : b;
2042}
2043
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002044// KHR_incremental_present aspect of QueuePresentKHR
2045static void SetSwapchainSurfaceDamage(ANativeWindow *window, const VkPresentRegionKHR *pRegion) {
2046 std::vector<android_native_rect_t> rects(pRegion->rectangleCount);
2047 for (auto i = 0u; i < pRegion->rectangleCount; i++) {
2048 auto const& rect = pRegion->pRectangles[i];
2049 if (rect.layer > 0) {
2050 ALOGV("vkQueuePresentKHR ignoring invalid layer (%u); using layer 0 instead",
2051 rect.layer);
2052 }
2053
2054 rects[i].left = rect.offset.x;
2055 rects[i].bottom = rect.offset.y;
2056 rects[i].right = rect.offset.x + rect.extent.width;
2057 rects[i].top = rect.offset.y + rect.extent.height;
2058 }
2059 native_window_set_surface_damage(window, rects.data(), rects.size());
2060}
2061
2062// GOOGLE_display_timing aspect of QueuePresentKHR
2063static void SetSwapchainFrameTimestamp(Swapchain &swapchain, const VkPresentTimeGOOGLE *pTime) {
2064 ANativeWindow *window = swapchain.surface.window.get();
2065
2066 // We don't know whether the app will actually use GOOGLE_display_timing
2067 // with a particular swapchain until QueuePresent; enable it on the BQ
2068 // now if needed
2069 if (!swapchain.frame_timestamps_enabled) {
2070 ALOGV("Calling native_window_enable_frame_timestamps(true)");
2071 native_window_enable_frame_timestamps(window, true);
2072 swapchain.frame_timestamps_enabled = true;
2073 }
2074
2075 // Record the nativeFrameId so it can be later correlated to
2076 // this present.
2077 uint64_t nativeFrameId = 0;
2078 int err = native_window_get_next_frame_id(
2079 window, &nativeFrameId);
2080 if (err != android::OK) {
2081 ALOGE("Failed to get next native frame ID.");
2082 }
2083
2084 // Add a new timing record with the user's presentID and
2085 // the nativeFrameId.
2086 swapchain.timing.emplace_back(pTime, nativeFrameId);
2087 if (swapchain.timing.size() > MAX_TIMING_INFOS) {
2088 swapchain.timing.erase(
2089 swapchain.timing.begin(),
2090 swapchain.timing.begin() + swapchain.timing.size() - MAX_TIMING_INFOS);
2091 }
2092 if (pTime->desiredPresentTime) {
2093 ALOGV(
2094 "Calling native_window_set_buffers_timestamp(%" PRId64 ")",
2095 pTime->desiredPresentTime);
2096 native_window_set_buffers_timestamp(
2097 window,
2098 static_cast<int64_t>(pTime->desiredPresentTime));
2099 }
2100}
2101
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002102// EXT_swapchain_maintenance1 present mode change
2103static bool SetSwapchainPresentMode(ANativeWindow *window, VkPresentModeKHR mode) {
2104 // There is no dynamic switching between non-shared present modes.
2105 // All we support is switching between demand and continuous refresh.
2106 if (!IsSharedPresentMode(mode))
2107 return true;
2108
2109 int err = native_window_set_auto_refresh(window,
2110 mode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
2111 if (err != android::OK) {
2112 ALOGE("native_window_set_auto_refresh() failed: %s (%d)",
2113 strerror(-err), err);
2114 return false;
2115 }
2116
2117 return true;
2118}
2119
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002120static VkResult PresentOneSwapchain(
2121 VkQueue queue,
2122 Swapchain& swapchain,
2123 uint32_t imageIndex,
2124 const VkPresentRegionKHR *pRegion,
2125 const VkPresentTimeGOOGLE *pTime,
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002126 VkFence presentFence,
2127 const VkPresentModeKHR *pPresentMode,
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002128 uint32_t waitSemaphoreCount,
2129 const VkSemaphore *pWaitSemaphores) {
2130
2131 VkDevice device = GetData(queue).driver_device;
2132 const auto& dispatch = GetData(queue).driver;
2133
2134 Swapchain::Image& img = swapchain.images[imageIndex];
2135 VkResult swapchain_result = VK_SUCCESS;
2136 VkResult result;
2137 int err;
2138
2139 // XXX: long standing issue: QueueSignalReleaseImageANDROID consumes the
2140 // wait semaphores, so this doesn't actually work for the multiple swapchain
2141 // case.
2142 int fence = -1;
2143 result = dispatch.QueueSignalReleaseImageANDROID(
2144 queue, waitSemaphoreCount,
2145 pWaitSemaphores, img.image, &fence);
2146 if (result != VK_SUCCESS) {
2147 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
2148 swapchain_result = result;
2149 }
2150 if (img.release_fence >= 0)
2151 close(img.release_fence);
2152 img.release_fence = fence < 0 ? -1 : dup(fence);
2153
2154 if (swapchain.surface.swapchain_handle == HandleFromSwapchain(&swapchain)) {
2155 ANativeWindow* window = swapchain.surface.window.get();
2156 if (swapchain_result == VK_SUCCESS) {
2157
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002158 if (presentFence != VK_NULL_HANDLE) {
2159 int fence_copy = fence < 0 ? -1 : dup(fence);
2160 VkImportFenceFdInfoKHR iffi = {
2161 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
2162 nullptr,
2163 presentFence,
2164 VK_FENCE_IMPORT_TEMPORARY_BIT,
2165 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
2166 fence_copy,
2167 };
2168 if (VK_SUCCESS != dispatch.ImportFenceFdKHR(device, &iffi) && fence_copy >= 0) {
2169 // ImportFenceFdKHR takes ownership only if it succeeds
2170 close(fence_copy);
2171 }
2172 }
2173
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002174 if (pRegion) {
2175 SetSwapchainSurfaceDamage(window, pRegion);
2176 }
2177 if (pTime) {
2178 SetSwapchainFrameTimestamp(swapchain, pTime);
2179 }
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002180 if (pPresentMode) {
2181 if (!SetSwapchainPresentMode(window, *pPresentMode))
2182 swapchain_result = WorstPresentResult(swapchain_result,
2183 VK_ERROR_SURFACE_LOST_KHR);
2184 }
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002185
2186 err = window->queueBuffer(window, img.buffer.get(), fence);
2187 // queueBuffer always closes fence, even on error
2188 if (err != android::OK) {
2189 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
2190 swapchain_result = WorstPresentResult(
2191 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
2192 } else {
2193 if (img.dequeue_fence >= 0) {
2194 close(img.dequeue_fence);
2195 img.dequeue_fence = -1;
2196 }
2197 img.dequeued = false;
2198 }
2199
2200 // If the swapchain is in shared mode, immediately dequeue the
2201 // buffer so it can be presented again without an intervening
2202 // call to AcquireNextImageKHR. We expect to get the same buffer
2203 // back from every call to dequeueBuffer in this mode.
2204 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
2205 ANativeWindowBuffer* buffer;
2206 int fence_fd;
2207 err = window->dequeueBuffer(window, &buffer, &fence_fd);
2208 if (err != android::OK) {
2209 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
2210 swapchain_result = WorstPresentResult(swapchain_result,
2211 VK_ERROR_SURFACE_LOST_KHR);
2212 } else if (img.buffer != buffer) {
2213 ALOGE("got wrong image back for shared swapchain");
2214 swapchain_result = WorstPresentResult(swapchain_result,
2215 VK_ERROR_SURFACE_LOST_KHR);
2216 } else {
2217 img.dequeue_fence = fence_fd;
2218 img.dequeued = true;
2219 }
2220 }
2221 }
2222 if (swapchain_result != VK_SUCCESS) {
2223 OrphanSwapchain(device, &swapchain);
2224 }
2225 // Android will only return VK_SUBOPTIMAL_KHR for vkQueuePresentKHR,
2226 // and only when the window's transform/rotation changes. Extent
2227 // changes will not cause VK_SUBOPTIMAL_KHR because of the
2228 // application issues that were caused when the following transform
2229 // change was added.
2230 int window_transform_hint;
2231 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
2232 &window_transform_hint);
2233 if (err != android::OK) {
2234 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
2235 strerror(-err), err);
2236 swapchain_result = WorstPresentResult(
2237 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
2238 }
2239 if (swapchain.pre_transform != window_transform_hint) {
2240 swapchain_result =
2241 WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
2242 }
2243 } else {
2244 ReleaseSwapchainImage(device, swapchain.shared, nullptr, fence,
2245 img, true);
2246 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
2247 }
2248
2249 return swapchain_result;
2250}
2251
Jesse Halle1b12782015-11-30 11:27:32 -08002252VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08002253VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002254 ATRACE_CALL();
2255
Jesse Halld7b994a2015-09-07 14:17:37 -07002256 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
2257 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
2258 present_info->sType);
Jesse Halld7b994a2015-09-07 14:17:37 -07002259
Jesse Halld7b994a2015-09-07 14:17:37 -07002260 VkResult final_result = VK_SUCCESS;
Jesse Halldc225072016-05-30 22:40:14 -07002261
Ian Elliottcb351132016-12-13 10:30:40 -07002262 // Look at the pNext chain for supported extension structs:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002263 const VkPresentRegionsKHR* present_regions = nullptr;
2264 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002265 const VkSwapchainPresentFenceInfoEXT* present_fences = nullptr;
2266 const VkSwapchainPresentModeInfoEXT* present_modes = nullptr;
2267
Ian Elliottcb351132016-12-13 10:30:40 -07002268 const VkPresentRegionsKHR* next =
2269 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
2270 while (next) {
2271 switch (next->sType) {
2272 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
2273 present_regions = next;
2274 break;
Ian Elliott14866bb2017-01-20 09:15:48 -07002275 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002276 present_times =
2277 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
2278 break;
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002279 case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
2280 present_fences =
2281 reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(next);
2282 break;
2283 case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
2284 present_modes =
2285 reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(next);
2286 break;
Ian Elliottcb351132016-12-13 10:30:40 -07002287 default:
2288 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
2289 next->sType);
2290 break;
2291 }
2292 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
2293 }
2294 ALOGV_IF(
2295 present_regions &&
2296 present_regions->swapchainCount != present_info->swapchainCount,
2297 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002298 ALOGV_IF(present_times &&
2299 present_times->swapchainCount != present_info->swapchainCount,
2300 "VkPresentTimesInfoGOOGLE::swapchainCount != "
2301 "VkPresentInfo::swapchainCount");
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002302 ALOGV_IF(present_fences &&
2303 present_fences->swapchainCount != present_info->swapchainCount,
2304 "VkSwapchainPresentFenceInfoEXT::swapchainCount != "
2305 "VkPresentInfo::swapchainCount");
2306 ALOGV_IF(present_modes &&
2307 present_modes->swapchainCount != present_info->swapchainCount,
2308 "VkSwapchainPresentModeInfoEXT::swapchainCount != "
2309 "VkPresentInfo::swapchainCount");
2310
Ian Elliottcb351132016-12-13 10:30:40 -07002311 const VkPresentRegionKHR* regions =
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002312 (present_regions) ? present_regions->pRegions : nullptr;
2313 const VkPresentTimeGOOGLE* times =
2314 (present_times) ? present_times->pTimes : nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07002315
Jesse Halld7b994a2015-09-07 14:17:37 -07002316 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
2317 Swapchain& swapchain =
Jesse Hall03b6fe12015-11-24 12:44:21 -08002318 *SwapchainFromHandle(present_info->pSwapchains[sc]);
Jesse Halld7b994a2015-09-07 14:17:37 -07002319
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002320 VkResult swapchain_result = PresentOneSwapchain(
2321 queue,
2322 swapchain,
2323 present_info->pImageIndices[sc],
2324 (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr,
2325 times ? &times[sc] : nullptr,
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002326 present_fences ? present_fences->pFences[sc] : VK_NULL_HANDLE,
2327 present_modes ? &present_modes->pPresentModes[sc] : nullptr,
Chris Forbes4cd01fb2022-10-19 11:35:16 +13002328 present_info->waitSemaphoreCount,
2329 present_info->pWaitSemaphores);
Jesse Halld7b994a2015-09-07 14:17:37 -07002330
Jesse Halla9e57032015-11-30 01:03:10 -08002331 if (present_info->pResults)
Jesse Halldc225072016-05-30 22:40:14 -07002332 present_info->pResults[sc] = swapchain_result;
2333
2334 if (swapchain_result != final_result)
2335 final_result = WorstPresentResult(final_result, swapchain_result);
Jesse Halld7b994a2015-09-07 14:17:37 -07002336 }
2337
2338 return final_result;
2339}
Jesse Hallb1352bc2015-09-04 16:12:33 -07002340
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002341VKAPI_ATTR
2342VkResult GetRefreshCycleDurationGOOGLE(
2343 VkDevice,
Ian Elliott62c48c92017-01-20 13:13:20 -07002344 VkSwapchainKHR swapchain_handle,
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002345 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002346 ATRACE_CALL();
2347
Ian Elliott62c48c92017-01-20 13:13:20 -07002348 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Alina Kalyakina3d6f3632023-03-22 17:13:47 +00002349 VkResult result = swapchain.get_refresh_duration(pDisplayTimingProperties->refreshDuration);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002350
2351 return result;
2352}
2353
2354VKAPI_ATTR
2355VkResult GetPastPresentationTimingGOOGLE(
2356 VkDevice,
2357 VkSwapchainKHR swapchain_handle,
2358 uint32_t* count,
2359 VkPastPresentationTimingGOOGLE* timings) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002360 ATRACE_CALL();
2361
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002362 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Yiwei Zhang9d187832019-07-22 15:15:47 -07002363 if (swapchain.surface.swapchain_handle != swapchain_handle) {
2364 return VK_ERROR_OUT_OF_DATE_KHR;
2365 }
2366
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002367 ANativeWindow* window = swapchain.surface.window.get();
2368 VkResult result = VK_SUCCESS;
2369
2370 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07002371 ALOGV("Calling native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002372 native_window_enable_frame_timestamps(window, true);
2373 swapchain.frame_timestamps_enabled = true;
2374 }
2375
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002376 if (timings) {
Yiwei Zhang9d187832019-07-22 15:15:47 -07002377 // Get the latest ready timing count before copying, since the copied
2378 // timing info will be erased in copy_ready_timings function.
2379 uint32_t n = get_num_ready_timings(swapchain);
Ian Elliott8a977262017-01-19 09:05:58 -07002380 copy_ready_timings(swapchain, count, timings);
Yiwei Zhang9d187832019-07-22 15:15:47 -07002381 // Check the *count here against the recorded ready timing count, since
2382 // *count can be overwritten per spec describes.
2383 if (*count < n) {
2384 result = VK_INCOMPLETE;
2385 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002386 } else {
Ian Elliott8a977262017-01-19 09:05:58 -07002387 *count = get_num_ready_timings(swapchain);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07002388 }
2389
2390 return result;
2391}
2392
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13002393VKAPI_ATTR
2394VkResult GetSwapchainStatusKHR(
2395 VkDevice,
Chris Forbes4e18ba82017-01-20 12:50:17 +13002396 VkSwapchainKHR swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002397 ATRACE_CALL();
2398
Chris Forbes4e18ba82017-01-20 12:50:17 +13002399 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13002400 VkResult result = VK_SUCCESS;
2401
Chris Forbes4e18ba82017-01-20 12:50:17 +13002402 if (swapchain.surface.swapchain_handle != swapchain_handle) {
2403 return VK_ERROR_OUT_OF_DATE_KHR;
2404 }
2405
Yiwei Zhanga885c062019-10-24 12:07:57 -07002406 // TODO(b/143296009): Implement this function properly
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13002407
2408 return result;
2409}
2410
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07002411VKAPI_ATTR void SetHdrMetadataEXT(
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08002412 VkDevice,
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07002413 uint32_t swapchainCount,
2414 const VkSwapchainKHR* pSwapchains,
2415 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08002416 ATRACE_CALL();
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08002417
2418 for (uint32_t idx = 0; idx < swapchainCount; idx++) {
2419 Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);
2420 if (!swapchain)
2421 continue;
2422
2423 if (swapchain->surface.swapchain_handle != pSwapchains[idx]) continue;
2424
2425 ANativeWindow* window = swapchain->surface.window.get();
2426
2427 VkHdrMetadataEXT vulkanMetadata = pHdrMetadataEXTs[idx];
2428 const android_smpte2086_metadata smpteMetdata = {
2429 {vulkanMetadata.displayPrimaryRed.x,
2430 vulkanMetadata.displayPrimaryRed.y},
2431 {vulkanMetadata.displayPrimaryGreen.x,
2432 vulkanMetadata.displayPrimaryGreen.y},
2433 {vulkanMetadata.displayPrimaryBlue.x,
2434 vulkanMetadata.displayPrimaryBlue.y},
2435 {vulkanMetadata.whitePoint.x, vulkanMetadata.whitePoint.y},
2436 vulkanMetadata.maxLuminance,
2437 vulkanMetadata.minLuminance};
2438 native_window_set_buffers_smpte2086_metadata(window, &smpteMetdata);
2439
2440 const android_cta861_3_metadata cta8613Metadata = {
2441 vulkanMetadata.maxContentLightLevel,
2442 vulkanMetadata.maxFrameAverageLightLevel};
2443 native_window_set_buffers_cta861_3_metadata(window, &cta8613Metadata);
2444 }
2445
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07002446 return;
2447}
2448
Yiwei Zhang0f475222019-04-11 19:38:00 -07002449static void InterceptBindImageMemory2(
2450 uint32_t bind_info_count,
2451 const VkBindImageMemoryInfo* bind_infos,
2452 std::vector<VkNativeBufferANDROID>* out_native_buffers,
2453 std::vector<VkBindImageMemoryInfo>* out_bind_infos) {
2454 out_native_buffers->clear();
2455 out_bind_infos->clear();
2456
2457 if (!bind_info_count)
2458 return;
2459
2460 std::unordered_set<uint32_t> intercepted_indexes;
2461
2462 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
2463 auto info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
2464 bind_infos[idx].pNext);
2465 while (info &&
2466 info->sType !=
2467 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR) {
2468 info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
2469 info->pNext);
2470 }
2471
2472 if (!info)
2473 continue;
2474
2475 ALOG_ASSERT(info->swapchain != VK_NULL_HANDLE,
2476 "swapchain handle must not be NULL");
2477 const Swapchain* swapchain = SwapchainFromHandle(info->swapchain);
2478 ALOG_ASSERT(
2479 info->imageIndex < swapchain->num_images,
2480 "imageIndex must be less than the number of images in swapchain");
2481
2482 ANativeWindowBuffer* buffer =
2483 swapchain->images[info->imageIndex].buffer.get();
2484 VkNativeBufferANDROID native_buffer = {
2485#pragma clang diagnostic push
2486#pragma clang diagnostic ignored "-Wold-style-cast"
2487 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
2488#pragma clang diagnostic pop
2489 .pNext = bind_infos[idx].pNext,
2490 .handle = buffer->handle,
2491 .stride = buffer->stride,
2492 .format = buffer->format,
2493 .usage = int(buffer->usage),
2494 };
2495 // Reserve enough space to avoid letting re-allocation invalidate the
2496 // addresses of the elements inside.
2497 out_native_buffers->reserve(bind_info_count);
2498 out_native_buffers->emplace_back(native_buffer);
2499
2500 // Reserve the space now since we know how much is needed now.
2501 out_bind_infos->reserve(bind_info_count);
2502 out_bind_infos->emplace_back(bind_infos[idx]);
2503 out_bind_infos->back().pNext = &out_native_buffers->back();
2504
2505 intercepted_indexes.insert(idx);
2506 }
2507
2508 if (intercepted_indexes.empty())
2509 return;
2510
2511 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
2512 if (intercepted_indexes.count(idx))
2513 continue;
2514 out_bind_infos->emplace_back(bind_infos[idx]);
2515 }
2516}
2517
Yiwei Zhang23143102019-04-10 18:24:05 -07002518VKAPI_ATTR
2519VkResult BindImageMemory2(VkDevice device,
2520 uint32_t bindInfoCount,
2521 const VkBindImageMemoryInfo* pBindInfos) {
2522 ATRACE_CALL();
2523
Yiwei Zhang0f475222019-04-11 19:38:00 -07002524 // out_native_buffers is for maintaining the lifecycle of the constructed
2525 // VkNativeBufferANDROID objects inside InterceptBindImageMemory2.
2526 std::vector<VkNativeBufferANDROID> out_native_buffers;
2527 std::vector<VkBindImageMemoryInfo> out_bind_infos;
2528 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
2529 &out_bind_infos);
2530 return GetData(device).driver.BindImageMemory2(
2531 device, bindInfoCount,
2532 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07002533}
2534
2535VKAPI_ATTR
2536VkResult BindImageMemory2KHR(VkDevice device,
2537 uint32_t bindInfoCount,
2538 const VkBindImageMemoryInfo* pBindInfos) {
2539 ATRACE_CALL();
2540
Yiwei Zhang0f475222019-04-11 19:38:00 -07002541 std::vector<VkNativeBufferANDROID> out_native_buffers;
2542 std::vector<VkBindImageMemoryInfo> out_bind_infos;
2543 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
2544 &out_bind_infos);
2545 return GetData(device).driver.BindImageMemory2KHR(
2546 device, bindInfoCount,
2547 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07002548}
2549
Chris Forbes9d0d9ff2022-12-28 01:58:31 +00002550VKAPI_ATTR
2551VkResult ReleaseSwapchainImagesEXT(VkDevice /*device*/,
2552 const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
2553 ATRACE_CALL();
2554
2555 Swapchain& swapchain = *SwapchainFromHandle(pReleaseInfo->swapchain);
2556 ANativeWindow* window = swapchain.surface.window.get();
2557
2558 // If in shared present mode, don't actually release the image back to the BQ.
2559 // Both sides share it forever.
2560 if (swapchain.shared)
2561 return VK_SUCCESS;
2562
2563 for (uint32_t i = 0; i < pReleaseInfo->imageIndexCount; i++) {
2564 Swapchain::Image& img = swapchain.images[pReleaseInfo->pImageIndices[i]];
2565 window->cancelBuffer(window, img.buffer.get(), img.dequeue_fence);
2566
2567 // cancelBuffer has taken ownership of the dequeue fence
2568 img.dequeue_fence = -1;
2569 // if we're still holding a release fence, get rid of it now
2570 if (img.release_fence >= 0) {
2571 close(img.release_fence);
2572 img.release_fence = -1;
2573 }
2574 img.dequeued = false;
2575 }
2576
2577 return VK_SUCCESS;
2578}
2579
Chia-I Wu62262232016-03-26 07:06:44 +08002580} // namespace driver
Jesse Hallb1352bc2015-09-04 16:12:33 -07002581} // namespace vulkan