blob: e6717d728004fcff5397389f9aca3ee40b3ae339 [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
Yiwei Zhang0f475222019-04-11 19:38:00 -070019#include <android/hardware/graphics/common/1.0/types.h>
Jesse Hall79927812017-03-23 11:03:23 -070020#include <grallocusage/GrallocUsageConversion.h>
Yiwei Zhang69395cd2019-07-03 16:55:39 -070021#include <graphicsenv/GraphicsEnv.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070022#include <log/log.h>
Jesse Halld7b994a2015-09-07 14:17:37 -070023#include <sync/sync.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070024#include <system/window.h>
25#include <ui/BufferQueueDefs.h>
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -050026#include <ui/DebugUtils.h>
27#include <ui/PixelFormat.h>
Chia-I Wue8e689f2016-04-18 08:21:31 +080028#include <utils/StrongPointer.h>
Yiwei Zhang705c2e62019-12-18 23:12:43 -080029#include <utils/Timers.h>
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -080030#include <utils/Trace.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070031
32#include <algorithm>
33#include <unordered_set>
34#include <vector>
Jesse Halld7b994a2015-09-07 14:17:37 -070035
Chia-I Wu4a6a9162016-03-26 07:17:34 +080036#include "driver.h"
Jesse Halld7b994a2015-09-07 14:17:37 -070037
Daniel Kochf25f5bb2017-10-05 00:26:58 -040038using android::hardware::graphics::common::V1_0::BufferUsage;
39
Chia-I Wu62262232016-03-26 07:06:44 +080040namespace vulkan {
41namespace driver {
Jesse Hall5ae3abb2015-10-08 14:00:22 -070042
Jesse Halld7b994a2015-09-07 14:17:37 -070043namespace {
44
Jesse Hall55bc0972016-02-23 16:43:29 -080045const VkSurfaceTransformFlagsKHR kSupportedTransforms =
46 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
47 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
48 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
49 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
Yiwei Zhang70a21962019-05-31 17:26:52 -070050 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
51 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
52 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
53 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
Jesse Hall55bc0972016-02-23 16:43:29 -080054 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
55
56VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
57 // Native and Vulkan transforms are isomorphic, but are represented
58 // differently. Vulkan transforms are built up of an optional horizontal
59 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
60 // transforms are built up from a horizontal flip, vertical flip, and
61 // 90-degree rotation, all optional but always in that order.
62
Jesse Hall55bc0972016-02-23 16:43:29 -080063 switch (native) {
Yiwei Zhang70a21962019-05-31 17:26:52 -070064 case 0:
Jesse Hall55bc0972016-02-23 16:43:29 -080065 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070066 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
67 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
68 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
69 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
70 case NATIVE_WINDOW_TRANSFORM_ROT_180:
Jesse Hall55bc0972016-02-23 16:43:29 -080071 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070072 case NATIVE_WINDOW_TRANSFORM_ROT_90:
Jesse Hall55bc0972016-02-23 16:43:29 -080073 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070074 case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
75 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
76 case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
77 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
78 case NATIVE_WINDOW_TRANSFORM_ROT_270:
Jesse Hall55bc0972016-02-23 16:43:29 -080079 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
80 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
81 default:
82 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
83 }
84}
85
Yiwei Zhang70a21962019-05-31 17:26:52 -070086int TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform) {
87 switch (transform) {
88 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
89 return NATIVE_WINDOW_TRANSFORM_ROT_90;
90 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
91 return NATIVE_WINDOW_TRANSFORM_ROT_180;
92 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
93 return NATIVE_WINDOW_TRANSFORM_ROT_270;
94 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
95 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
96 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
97 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
98 NATIVE_WINDOW_TRANSFORM_ROT_90;
99 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
100 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
101 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
102 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
103 NATIVE_WINDOW_TRANSFORM_ROT_90;
104 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
105 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
106 default:
107 return 0;
108 }
109}
110
Jesse Hall178b6962016-02-24 15:39:50 -0800111int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
112 switch (transform) {
113 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
114 return NATIVE_WINDOW_TRANSFORM_ROT_270;
115 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
116 return NATIVE_WINDOW_TRANSFORM_ROT_180;
117 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
118 return NATIVE_WINDOW_TRANSFORM_ROT_90;
Yiwei Zhang70a21962019-05-31 17:26:52 -0700119 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
120 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
121 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
122 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
123 NATIVE_WINDOW_TRANSFORM_ROT_90;
124 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
125 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
126 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
127 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
128 NATIVE_WINDOW_TRANSFORM_ROT_90;
Jesse Hall178b6962016-02-24 15:39:50 -0800129 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
130 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
131 default:
132 return 0;
133 }
134}
135
Ian Elliott8a977262017-01-19 09:05:58 -0700136class TimingInfo {
137 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800138 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
Ian Elliott2c6355d2017-01-19 11:02:13 -0700139 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
Brian Anderson1049d1d2016-12-16 17:25:57 -0800140 native_frame_id_(nativeFrameId) {}
141 bool ready() const {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700142 return (timestamp_desired_present_time_ !=
143 NATIVE_WINDOW_TIMESTAMP_PENDING &&
144 timestamp_actual_present_time_ !=
145 NATIVE_WINDOW_TIMESTAMP_PENDING &&
146 timestamp_render_complete_time_ !=
147 NATIVE_WINDOW_TIMESTAMP_PENDING &&
148 timestamp_composition_latch_time_ !=
149 NATIVE_WINDOW_TIMESTAMP_PENDING);
Ian Elliott8a977262017-01-19 09:05:58 -0700150 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700151 void calculate(int64_t rdur) {
152 bool anyTimestampInvalid =
153 (timestamp_actual_present_time_ ==
154 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
155 (timestamp_render_complete_time_ ==
156 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
157 (timestamp_composition_latch_time_ ==
158 NATIVE_WINDOW_TIMESTAMP_INVALID);
159 if (anyTimestampInvalid) {
160 ALOGE("Unexpectedly received invalid timestamp.");
161 vals_.actualPresentTime = 0;
162 vals_.earliestPresentTime = 0;
163 vals_.presentMargin = 0;
164 return;
165 }
166
167 vals_.actualPresentTime =
168 static_cast<uint64_t>(timestamp_actual_present_time_);
169 int64_t margin = (timestamp_composition_latch_time_ -
Ian Elliott8a977262017-01-19 09:05:58 -0700170 timestamp_render_complete_time_);
171 // Calculate vals_.earliestPresentTime, and potentially adjust
172 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
173 // is vals_.actualPresentTime. If we can subtract rdur (the duration
174 // of a refresh cycle) from vals_.earliestPresentTime (and also from
175 // vals_.presentMargin) and still leave a positive margin, then we can
176 // report to the application that it could have presented earlier than
177 // it did (per the extension specification). If for some reason, we
178 // can do this subtraction repeatedly, we do, since
179 // vals_.earliestPresentTime really is supposed to be the "earliest".
Brian Andersondc96fdf2017-03-20 16:54:25 -0700180 int64_t early_time = timestamp_actual_present_time_;
Ian Elliott8a977262017-01-19 09:05:58 -0700181 while ((margin > rdur) &&
182 ((early_time - rdur) > timestamp_composition_latch_time_)) {
183 early_time -= rdur;
184 margin -= rdur;
185 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700186 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
187 vals_.presentMargin = static_cast<uint64_t>(margin);
Ian Elliott8a977262017-01-19 09:05:58 -0700188 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800189 void get_values(VkPastPresentationTimingGOOGLE* values) const {
190 *values = vals_;
191 }
Ian Elliott8a977262017-01-19 09:05:58 -0700192
193 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800194 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700195
Brian Anderson1049d1d2016-12-16 17:25:57 -0800196 uint64_t native_frame_id_ { 0 };
Brian Andersondc96fdf2017-03-20 16:54:25 -0700197 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
198 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
199 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
200 int64_t timestamp_composition_latch_time_
201 { NATIVE_WINDOW_TIMESTAMP_PENDING };
Ian Elliott8a977262017-01-19 09:05:58 -0700202};
203
Jesse Hall1356b0d2015-11-23 17:24:58 -0800204struct Surface {
Chia-I Wue8e689f2016-04-18 08:21:31 +0800205 android::sp<ANativeWindow> window;
Jesse Halldc225072016-05-30 22:40:14 -0700206 VkSwapchainKHR swapchain_handle;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700207 uint64_t consumer_usage;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800208};
209
210VkSurfaceKHR HandleFromSurface(Surface* surface) {
211 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
212}
213
214Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800215 return reinterpret_cast<Surface*>(handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800216}
217
Ian Elliott8a977262017-01-19 09:05:58 -0700218// Maximum number of TimingInfo structs to keep per swapchain:
219enum { MAX_TIMING_INFOS = 10 };
220// Minimum number of frames to look for in the past (so we don't cause
221// syncronous requests to Surface Flinger):
222enum { MIN_NUM_FRAMES_AGO = 5 };
223
Jesse Hall1356b0d2015-11-23 17:24:58 -0800224struct Swapchain {
Ian Elliottffedb652017-02-14 10:58:30 -0700225 Swapchain(Surface& surface_,
226 uint32_t num_images_,
silence_dogood73597592019-05-23 16:57:37 -0700227 VkPresentModeKHR present_mode,
228 int pre_transform_)
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700229 : surface(surface_),
230 num_images(num_images_),
Ian Elliottffedb652017-02-14 10:58:30 -0700231 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
silence_dogood73597592019-05-23 16:57:37 -0700232 pre_transform(pre_transform_),
Chris Forbesf8835642017-03-30 19:31:40 +1300233 frame_timestamps_enabled(false),
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800234 acquire_next_image_timeout(-1),
Chris Forbesf8835642017-03-30 19:31:40 +1300235 shared(present_mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800236 present_mode ==
237 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Ian Elliott62c48c92017-01-20 13:13:20 -0700238 ANativeWindow* window = surface.window.get();
Ian Elliottbe833a22017-01-25 13:09:20 -0700239 native_window_get_refresh_cycle_duration(
Ian Elliott62c48c92017-01-20 13:13:20 -0700240 window,
Brian Andersondc96fdf2017-03-20 16:54:25 -0700241 &refresh_duration);
Ian Elliott8a977262017-01-19 09:05:58 -0700242 }
Ian Elliott3568bfe2019-05-03 15:54:46 -0600243 uint64_t get_refresh_duration()
244 {
245 ANativeWindow* window = surface.window.get();
246 native_window_get_refresh_cycle_duration(
247 window,
248 &refresh_duration);
249 return static_cast<uint64_t>(refresh_duration);
250
251 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800252
253 Surface& surface;
Jesse Halld7b994a2015-09-07 14:17:37 -0700254 uint32_t num_images;
Ian Elliottffedb652017-02-14 10:58:30 -0700255 bool mailbox_mode;
silence_dogood73597592019-05-23 16:57:37 -0700256 int pre_transform;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700257 bool frame_timestamps_enabled;
Brian Andersondc96fdf2017-03-20 16:54:25 -0700258 int64_t refresh_duration;
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800259 nsecs_t acquire_next_image_timeout;
Chris Forbesf8835642017-03-30 19:31:40 +1300260 bool shared;
Jesse Halld7b994a2015-09-07 14:17:37 -0700261
262 struct Image {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700263 Image()
264 : image(VK_NULL_HANDLE),
265 dequeue_fence(-1),
266 release_fence(-1),
267 dequeued(false) {}
Jesse Halld7b994a2015-09-07 14:17:37 -0700268 VkImage image;
Chia-I Wue8e689f2016-04-18 08:21:31 +0800269 android::sp<ANativeWindowBuffer> buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -0700270 // The fence is only valid when the buffer is dequeued, and should be
271 // -1 any other time. When valid, we own the fd, and must ensure it is
272 // closed: either by closing it explicitly when queueing the buffer,
273 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
274 int dequeue_fence;
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700275 // This fence is a dup of the sync fd returned from the driver via
276 // vkQueueSignalReleaseImageANDROID upon vkQueuePresentKHR. We must
277 // ensure it is closed upon re-presenting or releasing the image.
278 int release_fence;
Jesse Halld7b994a2015-09-07 14:17:37 -0700279 bool dequeued;
Pawin Vongmasa6e1193a2017-03-07 13:08:40 -0800280 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
Ian Elliott8a977262017-01-19 09:05:58 -0700281
Yiwei Zhang5e862202019-06-21 14:59:16 -0700282 std::vector<TimingInfo> timing;
Jesse Halld7b994a2015-09-07 14:17:37 -0700283};
284
285VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
286 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
287}
288
289Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800290 return reinterpret_cast<Swapchain*>(handle);
Jesse Halld7b994a2015-09-07 14:17:37 -0700291}
292
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700293static bool IsFencePending(int fd) {
294 if (fd < 0)
295 return false;
296
297 errno = 0;
298 return sync_wait(fd, 0 /* timeout */) == -1 && errno == ETIME;
299}
300
Jesse Halldc225072016-05-30 22:40:14 -0700301void ReleaseSwapchainImage(VkDevice device,
302 ANativeWindow* window,
303 int release_fence,
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700304 Swapchain::Image& image,
305 bool defer_if_pending) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700306 ATRACE_CALL();
307
Jesse Halldc225072016-05-30 22:40:14 -0700308 ALOG_ASSERT(release_fence == -1 || image.dequeued,
309 "ReleaseSwapchainImage: can't provide a release fence for "
310 "non-dequeued images");
311
312 if (image.dequeued) {
313 if (release_fence >= 0) {
314 // We get here from vkQueuePresentKHR. The application is
315 // responsible for creating an execution dependency chain from
316 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
317 // (release_fence), so we can drop the dequeue_fence here.
318 if (image.dequeue_fence >= 0)
319 close(image.dequeue_fence);
320 } else {
321 // We get here during swapchain destruction, or various serious
322 // error cases e.g. when we can't create the release_fence during
323 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
324 // have already signalled, since the swapchain images are supposed
325 // to be idle before the swapchain is destroyed. In error cases,
326 // there may be rendering in flight to the image, but since we
327 // weren't able to create a release_fence, waiting for the
328 // dequeue_fence is about the best we can do.
329 release_fence = image.dequeue_fence;
330 }
331 image.dequeue_fence = -1;
332
333 if (window) {
334 window->cancelBuffer(window, image.buffer.get(), release_fence);
335 } else {
336 if (release_fence >= 0) {
337 sync_wait(release_fence, -1 /* forever */);
338 close(release_fence);
339 }
340 }
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700341 release_fence = -1;
Jesse Halldc225072016-05-30 22:40:14 -0700342 image.dequeued = false;
343 }
344
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700345 if (defer_if_pending && IsFencePending(image.release_fence))
346 return;
347
348 if (image.release_fence >= 0) {
349 close(image.release_fence);
350 image.release_fence = -1;
351 }
352
Jesse Halldc225072016-05-30 22:40:14 -0700353 if (image.image) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700354 ATRACE_BEGIN("DestroyImage");
Jesse Halldc225072016-05-30 22:40:14 -0700355 GetData(device).driver.DestroyImage(device, image.image, nullptr);
Yiwei Zhang533cea92019-06-03 18:43:24 -0700356 ATRACE_END();
Jesse Halldc225072016-05-30 22:40:14 -0700357 image.image = VK_NULL_HANDLE;
358 }
359
360 image.buffer.clear();
361}
362
363void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
364 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
365 return;
Jesse Halldc225072016-05-30 22:40:14 -0700366 for (uint32_t i = 0; i < swapchain->num_images; i++) {
367 if (!swapchain->images[i].dequeued)
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700368 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i],
369 true);
Jesse Halldc225072016-05-30 22:40:14 -0700370 }
371 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Ian Elliott8a977262017-01-19 09:05:58 -0700372 swapchain->timing.clear();
373}
374
375uint32_t get_num_ready_timings(Swapchain& swapchain) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800376 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
377 return 0;
378 }
Ian Elliott8a977262017-01-19 09:05:58 -0700379
Brian Anderson1049d1d2016-12-16 17:25:57 -0800380 uint32_t num_ready = 0;
381 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
382 for (uint32_t i = 0; i < num_timings; i++) {
Yiwei Zhang5e862202019-06-21 14:59:16 -0700383 TimingInfo& ti = swapchain.timing[i];
Brian Anderson1049d1d2016-12-16 17:25:57 -0800384 if (ti.ready()) {
385 // This TimingInfo is ready to be reported to the user. Add it
386 // to the num_ready.
387 num_ready++;
388 continue;
389 }
390 // This TimingInfo is not yet ready to be reported to the user,
391 // and so we should look for any available timestamps that
392 // might make it ready.
393 int64_t desired_present_time = 0;
394 int64_t render_complete_time = 0;
395 int64_t composition_latch_time = 0;
396 int64_t actual_present_time = 0;
397 // Obtain timestamps:
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800398 int err = native_window_get_frame_timestamps(
Brian Anderson1049d1d2016-12-16 17:25:57 -0800399 swapchain.surface.window.get(), ti.native_frame_id_,
400 &desired_present_time, &render_complete_time,
401 &composition_latch_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700402 nullptr, //&first_composition_start_time,
403 nullptr, //&last_composition_start_time,
404 nullptr, //&composition_finish_time,
Brian Anderson1049d1d2016-12-16 17:25:57 -0800405 &actual_present_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700406 nullptr, //&dequeue_ready_time,
407 nullptr /*&reads_done_time*/);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800408
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800409 if (err != android::OK) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800410 continue;
411 }
412
413 // Record the timestamp(s) we received, and then see if this TimingInfo
414 // is ready to be reported to the user:
Brian Andersondc96fdf2017-03-20 16:54:25 -0700415 ti.timestamp_desired_present_time_ = desired_present_time;
416 ti.timestamp_actual_present_time_ = actual_present_time;
417 ti.timestamp_render_complete_time_ = render_complete_time;
418 ti.timestamp_composition_latch_time_ = composition_latch_time;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800419
420 if (ti.ready()) {
421 // The TimingInfo has received enough timestamps, and should now
422 // use those timestamps to calculate the info that should be
423 // reported to the user:
424 ti.calculate(swapchain.refresh_duration);
425 num_ready++;
Ian Elliott8a977262017-01-19 09:05:58 -0700426 }
427 }
428 return num_ready;
429}
430
Ian Elliott8a977262017-01-19 09:05:58 -0700431void copy_ready_timings(Swapchain& swapchain,
432 uint32_t* count,
433 VkPastPresentationTimingGOOGLE* timings) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800434 if (swapchain.timing.empty()) {
435 *count = 0;
436 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700437 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800438
439 size_t last_ready = swapchain.timing.size() - 1;
440 while (!swapchain.timing[last_ready].ready()) {
441 if (last_ready == 0) {
442 *count = 0;
443 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700444 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800445 last_ready--;
Ian Elliott8a977262017-01-19 09:05:58 -0700446 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800447
448 uint32_t num_copied = 0;
Yiwei Zhang5e862202019-06-21 14:59:16 -0700449 int32_t num_to_remove = 0;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800450 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
451 const TimingInfo& ti = swapchain.timing[i];
452 if (ti.ready()) {
453 ti.get_values(&timings[num_copied]);
454 num_copied++;
455 }
456 num_to_remove++;
457 }
458
459 // Discard old frames that aren't ready if newer frames are ready.
460 // We don't expect to get the timing info for those old frames.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700461 swapchain.timing.erase(swapchain.timing.begin(),
462 swapchain.timing.begin() + num_to_remove);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800463
Ian Elliott8a977262017-01-19 09:05:58 -0700464 *count = num_copied;
Jesse Halldc225072016-05-30 22:40:14 -0700465}
466
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500467android::PixelFormat GetNativePixelFormat(VkFormat format) {
468 android::PixelFormat native_format = android::PIXEL_FORMAT_RGBA_8888;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700469 switch (format) {
470 case VK_FORMAT_R8G8B8A8_UNORM:
471 case VK_FORMAT_R8G8B8A8_SRGB:
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500472 native_format = android::PIXEL_FORMAT_RGBA_8888;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700473 break;
474 case VK_FORMAT_R5G6B5_UNORM_PACK16:
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500475 native_format = android::PIXEL_FORMAT_RGB_565;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700476 break;
477 case VK_FORMAT_R16G16B16A16_SFLOAT:
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500478 native_format = android::PIXEL_FORMAT_RGBA_FP16;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700479 break;
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800480 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500481 native_format = android::PIXEL_FORMAT_RGBA_1010102;
482 break;
483 case VK_FORMAT_R8_UNORM:
484 native_format = android::PIXEL_FORMAT_R_8;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700485 break;
486 default:
487 ALOGV("unsupported swapchain format %d", format);
488 break;
489 }
490 return native_format;
491}
492
493android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
494 switch (colorspace) {
495 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
496 return HAL_DATASPACE_V0_SRGB;
497 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
498 return HAL_DATASPACE_DISPLAY_P3;
499 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
500 return HAL_DATASPACE_V0_SCRGB_LINEAR;
Courtney Goeltzenleuchterb52abee2017-08-07 17:13:04 -0600501 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
502 return HAL_DATASPACE_V0_SCRGB;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700503 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
504 return HAL_DATASPACE_DCI_P3_LINEAR;
505 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
506 return HAL_DATASPACE_DCI_P3;
507 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
508 return HAL_DATASPACE_V0_SRGB_LINEAR;
509 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
510 return HAL_DATASPACE_V0_SRGB;
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600511 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
512 return HAL_DATASPACE_BT2020_LINEAR;
513 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700514 return static_cast<android_dataspace>(
515 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
516 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600517 case VK_COLOR_SPACE_DOLBYVISION_EXT:
518 return static_cast<android_dataspace>(
519 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
520 HAL_DATASPACE_RANGE_FULL);
521 case VK_COLOR_SPACE_HDR10_HLG_EXT:
522 return static_cast<android_dataspace>(
523 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_HLG |
524 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700525 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
526 return static_cast<android_dataspace>(
527 HAL_DATASPACE_STANDARD_ADOBE_RGB |
528 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
529 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
530 return HAL_DATASPACE_ADOBE_RGB;
531
532 // Pass through is intended to allow app to provide data that is passed
533 // to the display system without modification.
534 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
535 return HAL_DATASPACE_ARBITRARY;
536
537 default:
538 // This indicates that we don't know about the
539 // dataspace specified and we should indicate that
540 // it's unsupported
541 return HAL_DATASPACE_UNKNOWN;
542 }
543}
544
Jesse Halld7b994a2015-09-07 14:17:37 -0700545} // anonymous namespace
Jesse Hallb1352bc2015-09-04 16:12:33 -0700546
Jesse Halle1b12782015-11-30 11:27:32 -0800547VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800548VkResult CreateAndroidSurfaceKHR(
Jesse Hallf9fa9a52016-01-08 16:08:51 -0800549 VkInstance instance,
550 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
551 const VkAllocationCallbacks* allocator,
552 VkSurfaceKHR* out_surface) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800553 ATRACE_CALL();
554
Jesse Hall1f91d392015-12-11 16:28:44 -0800555 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800556 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800557 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
558 alignof(Surface),
559 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800560 if (!mem)
561 return VK_ERROR_OUT_OF_HOST_MEMORY;
562 Surface* surface = new (mem) Surface;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700563
Chia-I Wue8e689f2016-04-18 08:21:31 +0800564 surface->window = pCreateInfo->window;
Jesse Halldc225072016-05-30 22:40:14 -0700565 surface->swapchain_handle = VK_NULL_HANDLE;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700566 int err = native_window_get_consumer_usage(surface->window.get(),
567 &surface->consumer_usage);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800568 if (err != android::OK) {
Yiwei Zhang6435b322018-05-08 11:12:17 -0700569 ALOGE("native_window_get_consumer_usage() failed: %s (%d)",
570 strerror(-err), err);
571 surface->~Surface();
572 allocator->pfnFree(allocator->pUserData, surface);
Yiwei Zhang70a21962019-05-31 17:26:52 -0700573 return VK_ERROR_SURFACE_LOST_KHR;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700574 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700575
Yiwei Zhang6435b322018-05-08 11:12:17 -0700576 err =
Jesse Hall1356b0d2015-11-23 17:24:58 -0800577 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800578 if (err != android::OK) {
Jesse Hall1356b0d2015-11-23 17:24:58 -0800579 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
580 err);
581 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800582 allocator->pfnFree(allocator->pUserData, surface);
Mike Stroyan762c8132017-02-22 11:43:09 -0700583 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800584 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700585
Jesse Hall1356b0d2015-11-23 17:24:58 -0800586 *out_surface = HandleFromSurface(surface);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700587 return VK_SUCCESS;
588}
589
Jesse Halle1b12782015-11-30 11:27:32 -0800590VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800591void DestroySurfaceKHR(VkInstance instance,
592 VkSurfaceKHR surface_handle,
593 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800594 ATRACE_CALL();
595
Jesse Hall1356b0d2015-11-23 17:24:58 -0800596 Surface* surface = SurfaceFromHandle(surface_handle);
597 if (!surface)
598 return;
599 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700600 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
Jesse Halldc225072016-05-30 22:40:14 -0700601 "destroyed VkSurfaceKHR 0x%" PRIx64
602 " has active VkSwapchainKHR 0x%" PRIx64,
603 reinterpret_cast<uint64_t>(surface_handle),
604 reinterpret_cast<uint64_t>(surface->swapchain_handle));
Jesse Hall1356b0d2015-11-23 17:24:58 -0800605 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800606 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800607 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800608 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800609}
610
Jesse Halle1b12782015-11-30 11:27:32 -0800611VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800612VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
613 uint32_t /*queue_family*/,
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000614 VkSurfaceKHR /*surface_handle*/,
Chia-I Wu62262232016-03-26 07:06:44 +0800615 VkBool32* supported) {
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000616 *supported = VK_TRUE;
Jesse Halla6429252015-11-29 18:59:42 -0800617 return VK_SUCCESS;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800618}
619
Jesse Halle1b12782015-11-30 11:27:32 -0800620VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800621VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
Jesse Hallb00daad2015-11-29 19:46:20 -0800622 VkPhysicalDevice /*pdev*/,
623 VkSurfaceKHR surface,
624 VkSurfaceCapabilitiesKHR* capabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800625 ATRACE_CALL();
626
Jesse Halld7b994a2015-09-07 14:17:37 -0700627 int err;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800628 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -0700629
630 int width, height;
631 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800632 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -0700633 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
634 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700635 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700636 }
637 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800638 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -0700639 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
640 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700641 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700642 }
643
Jesse Hall55bc0972016-02-23 16:43:29 -0800644 int transform_hint;
645 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800646 if (err != android::OK) {
Jesse Hall55bc0972016-02-23 16:43:29 -0800647 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
648 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700649 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall55bc0972016-02-23 16:43:29 -0800650 }
651
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800652 int max_buffer_count;
653 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800654 if (err != android::OK) {
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800655 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
656 strerror(-err), err);
657 return VK_ERROR_SURFACE_LOST_KHR;
658 }
Ian Elliott16c443c2021-11-30 17:10:32 -0700659 capabilities->minImageCount = std::min(max_buffer_count, 3);
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800660 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
Jesse Halld7b994a2015-09-07 14:17:37 -0700661
Jesse Hallfe2662d2016-02-09 13:26:59 -0800662 capabilities->currentExtent =
663 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
664
Yiwei Zhang70a21962019-05-31 17:26:52 -0700665 // TODO(http://b/134182502): Figure out what the max extent should be.
Jesse Hallb00daad2015-11-29 19:46:20 -0800666 capabilities->minImageExtent = VkExtent2D{1, 1};
667 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
Jesse Halld7b994a2015-09-07 14:17:37 -0700668
Jesse Hallfe2662d2016-02-09 13:26:59 -0800669 capabilities->maxImageArrayLayers = 1;
670
Jesse Hall55bc0972016-02-23 16:43:29 -0800671 capabilities->supportedTransforms = kSupportedTransforms;
672 capabilities->currentTransform =
673 TranslateNativeToVulkanTransform(transform_hint);
Jesse Halld7b994a2015-09-07 14:17:37 -0700674
Jesse Hallfe2662d2016-02-09 13:26:59 -0800675 // On Android, window composition is a WindowManager property, not something
676 // associated with the bufferqueue. It can't be changed from here.
677 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700678
Jesse Hallb00daad2015-11-29 19:46:20 -0800679 capabilities->supportedUsageFlags =
Jesse Hall3fbc8562015-11-29 22:10:52 -0800680 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
681 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
682 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
Jesse Halld7b994a2015-09-07 14:17:37 -0700683 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
684
Jesse Hallb1352bc2015-09-04 16:12:33 -0700685 return VK_SUCCESS;
686}
687
Jesse Halle1b12782015-11-30 11:27:32 -0800688VKAPI_ATTR
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700689VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
690 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800691 uint32_t* count,
692 VkSurfaceFormatKHR* formats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800693 ATRACE_CALL();
694
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700695 const InstanceData& instance_data = GetData(pdev);
696
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700697 bool wide_color_support = false;
698 Surface& surface = *SurfaceFromHandle(surface_handle);
699 int err = native_window_get_wide_color_support(surface.window.get(),
700 &wide_color_support);
701 if (err) {
Yiwei Zhang70a21962019-05-31 17:26:52 -0700702 return VK_ERROR_SURFACE_LOST_KHR;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700703 }
Trevor David Blackea5745a2021-11-23 17:27:23 +0000704 bool swapchain_ext =
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700705 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
Trevor David Blackea5745a2021-11-23 17:27:23 +0000706 ALOGV("wide_color_support is: %d", wide_color_support);
707 wide_color_support = wide_color_support && swapchain_ext;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700708
Charlie Lao324191f2019-12-13 11:03:16 -0800709 AHardwareBuffer_Desc desc = {};
710 desc.width = 1;
711 desc.height = 1;
712 desc.layers = 1;
713 desc.usage = surface.consumer_usage |
714 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
715 AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
716
717 // We must support R8G8B8A8
718 std::vector<VkSurfaceFormatKHR> all_formats = {
719 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Trevor David Blackea5745a2021-11-23 17:27:23 +0000720 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}};
721
722 if (swapchain_ext) {
723 all_formats.emplace_back(VkSurfaceFormatKHR{
724 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT});
725 }
Charlie Lao324191f2019-12-13 11:03:16 -0800726
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700727 if (wide_color_support) {
Charlie Lao324191f2019-12-13 11:03:16 -0800728 all_formats.emplace_back(VkSurfaceFormatKHR{
729 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
730 all_formats.emplace_back(VkSurfaceFormatKHR{
731 VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
732 }
733
734 desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
735 if (AHardwareBuffer_isSupported(&desc)) {
736 all_formats.emplace_back(VkSurfaceFormatKHR{
737 VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
738 }
739
740 desc.format = AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
741 if (AHardwareBuffer_isSupported(&desc)) {
742 all_formats.emplace_back(VkSurfaceFormatKHR{
743 VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
744 if (wide_color_support) {
745 all_formats.emplace_back(
746 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
747 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT});
748 all_formats.emplace_back(
749 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
750 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT});
751 }
752 }
753
754 desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
755 if (AHardwareBuffer_isSupported(&desc)) {
756 all_formats.emplace_back(
757 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
758 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
759 if (wide_color_support) {
760 all_formats.emplace_back(
761 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
762 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
763 }
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700764 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700765
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -0500766 desc.format = AHARDWAREBUFFER_FORMAT_R8_UNORM;
767 if (AHardwareBuffer_isSupported(&desc)) {
768 all_formats.emplace_back(
769 VkSurfaceFormatKHR{VK_FORMAT_R8_UNORM,
770 VK_COLOR_SPACE_PASS_THROUGH_EXT});
771 }
772
Jesse Halld7b994a2015-09-07 14:17:37 -0700773 VkResult result = VK_SUCCESS;
774 if (formats) {
Charlie Lao324191f2019-12-13 11:03:16 -0800775 uint32_t transfer_count = all_formats.size();
776 if (transfer_count > *count) {
777 transfer_count = *count;
Jesse Halld7b994a2015-09-07 14:17:37 -0700778 result = VK_INCOMPLETE;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700779 }
Charlie Lao324191f2019-12-13 11:03:16 -0800780 std::copy(all_formats.begin(), all_formats.begin() + transfer_count,
781 formats);
782 *count = transfer_count;
Jesse Hall7331e222016-09-15 21:26:01 -0700783 } else {
Charlie Lao324191f2019-12-13 11:03:16 -0800784 *count = all_formats.size();
Jesse Halld7b994a2015-09-07 14:17:37 -0700785 }
Charlie Lao324191f2019-12-13 11:03:16 -0800786
Jesse Halld7b994a2015-09-07 14:17:37 -0700787 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700788}
789
Jesse Halle1b12782015-11-30 11:27:32 -0800790VKAPI_ATTR
Chris Forbes2452cf72017-03-16 16:30:17 +1300791VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
792 VkPhysicalDevice physicalDevice,
793 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
794 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800795 ATRACE_CALL();
796
Chris Forbes2452cf72017-03-16 16:30:17 +1300797 VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
798 physicalDevice, pSurfaceInfo->surface,
799 &pSurfaceCapabilities->surfaceCapabilities);
800
Chris Forbes06bc0092017-03-16 16:46:05 +1300801 VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
802 while (caps->pNext) {
803 caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
804
805 switch (caps->sType) {
806 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
807 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
808 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
809 caps);
810 // Claim same set of usage flags are supported for
811 // shared present modes as for other modes.
812 shared_caps->sharedPresentSupportedUsageFlags =
813 pSurfaceCapabilities->surfaceCapabilities
814 .supportedUsageFlags;
815 } break;
816
817 default:
818 // Ignore all other extension structs
819 break;
820 }
821 }
822
Chris Forbes2452cf72017-03-16 16:30:17 +1300823 return result;
824}
825
826VKAPI_ATTR
827VkResult GetPhysicalDeviceSurfaceFormats2KHR(
828 VkPhysicalDevice physicalDevice,
829 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
830 uint32_t* pSurfaceFormatCount,
831 VkSurfaceFormat2KHR* pSurfaceFormats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800832 ATRACE_CALL();
833
Chris Forbes2452cf72017-03-16 16:30:17 +1300834 if (!pSurfaceFormats) {
835 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
836 pSurfaceInfo->surface,
837 pSurfaceFormatCount, nullptr);
838 } else {
839 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
840 // after the call.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700841 std::vector<VkSurfaceFormatKHR> surface_formats(*pSurfaceFormatCount);
Chris Forbes2452cf72017-03-16 16:30:17 +1300842 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
843 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
Yiwei Zhang5e862202019-06-21 14:59:16 -0700844 surface_formats.data());
Chris Forbes2452cf72017-03-16 16:30:17 +1300845
846 if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
847 // marshal results individually due to stride difference.
848 // completely ignore any chained extension structs.
849 uint32_t formats_to_marshal = *pSurfaceFormatCount;
850 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
851 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
852 }
853 }
854
855 return result;
856 }
857}
858
859VKAPI_ATTR
Chris Forbese8d79a62017-02-22 12:49:18 +1300860VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800861 VkSurfaceKHR surface,
Chia-I Wu62262232016-03-26 07:06:44 +0800862 uint32_t* count,
863 VkPresentModeKHR* modes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800864 ATRACE_CALL();
865
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800866 int err;
867 int query_value;
868 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
869
Ian Elliott16c443c2021-11-30 17:10:32 -0700870 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
871 &query_value);
872 if (err != android::OK || query_value < 0) {
873 ALOGE(
874 "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) "
875 "value=%d",
876 strerror(-err), err, query_value);
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800877 return VK_ERROR_SURFACE_LOST_KHR;
878 }
Ian Elliott16c443c2021-11-30 17:10:32 -0700879 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800880
881 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800882 if (err != android::OK || query_value < 0) {
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800883 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
884 strerror(-err), err, query_value);
885 return VK_ERROR_SURFACE_LOST_KHR;
886 }
887 uint32_t max_buffer_count = static_cast<uint32_t>(query_value);
888
Yiwei Zhang5e862202019-06-21 14:59:16 -0700889 std::vector<VkPresentModeKHR> present_modes;
Ian Elliott16c443c2021-11-30 17:10:32 -0700890 if (min_undequeued_buffers + 1 < max_buffer_count)
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800891 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
Chris Forbese8d79a62017-02-22 12:49:18 +1300892 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
893
894 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
Yiwei Zhang93b521c2020-07-11 16:32:09 -0700895 QueryPresentationProperties(pdev, &present_properties);
896 if (present_properties.sharedImage) {
897 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
898 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
Chris Forbese8d79a62017-02-22 12:49:18 +1300899 }
900
901 uint32_t num_modes = uint32_t(present_modes.size());
Jesse Halld7b994a2015-09-07 14:17:37 -0700902
903 VkResult result = VK_SUCCESS;
904 if (modes) {
Chris Forbese8d79a62017-02-22 12:49:18 +1300905 if (*count < num_modes)
Jesse Halld7b994a2015-09-07 14:17:37 -0700906 result = VK_INCOMPLETE;
Chris Forbese8d79a62017-02-22 12:49:18 +1300907 *count = std::min(*count, num_modes);
Yiwei Zhang5e862202019-06-21 14:59:16 -0700908 std::copy_n(present_modes.data(), *count, modes);
Jesse Hall7331e222016-09-15 21:26:01 -0700909 } else {
Chris Forbese8d79a62017-02-22 12:49:18 +1300910 *count = num_modes;
Jesse Halld7b994a2015-09-07 14:17:37 -0700911 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700912 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700913}
914
Jesse Halle1b12782015-11-30 11:27:32 -0800915VKAPI_ATTR
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400916VkResult GetDeviceGroupPresentCapabilitiesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -0600917 VkDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400918 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800919 ATRACE_CALL();
920
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400921 ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
922 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
923 "vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
924 "VkDeviceGroupPresentCapabilitiesKHR structure type %d",
925 pDeviceGroupPresentCapabilities->sType);
926
927 memset(pDeviceGroupPresentCapabilities->presentMask, 0,
928 sizeof(pDeviceGroupPresentCapabilities->presentMask));
929
930 // assume device group of size 1
931 pDeviceGroupPresentCapabilities->presentMask[0] = 1 << 0;
932 pDeviceGroupPresentCapabilities->modes =
933 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
934
935 return VK_SUCCESS;
936}
937
938VKAPI_ATTR
939VkResult GetDeviceGroupSurfacePresentModesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -0600940 VkDevice,
941 VkSurfaceKHR,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400942 VkDeviceGroupPresentModeFlagsKHR* pModes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800943 ATRACE_CALL();
944
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400945 *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
946 return VK_SUCCESS;
947}
948
949VKAPI_ATTR
Ian Elliottcd8ad332017-10-13 09:21:12 -0600950VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400951 VkSurfaceKHR surface,
952 uint32_t* pRectCount,
953 VkRect2D* pRects) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800954 ATRACE_CALL();
955
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400956 if (!pRects) {
957 *pRectCount = 1;
958 } else {
959 uint32_t count = std::min(*pRectCount, 1u);
960 bool incomplete = *pRectCount < 1;
961
962 *pRectCount = count;
963
964 if (incomplete) {
965 return VK_INCOMPLETE;
966 }
967
968 int err;
969 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
970
971 int width = 0, height = 0;
972 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800973 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400974 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
975 strerror(-err), err);
976 }
977 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800978 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400979 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
980 strerror(-err), err);
981 }
982
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400983 pRects[0].offset.x = 0;
984 pRects[0].offset.y = 0;
985 pRects[0].extent = VkExtent2D{static_cast<uint32_t>(width),
986 static_cast<uint32_t>(height)};
987 }
988 return VK_SUCCESS;
989}
990
Yiwei Zhang533cea92019-06-03 18:43:24 -0700991static void DestroySwapchainInternal(VkDevice device,
992 VkSwapchainKHR swapchain_handle,
993 const VkAllocationCallbacks* allocator) {
994 ATRACE_CALL();
995
996 const auto& dispatch = GetData(device).driver;
997 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
998 if (!swapchain) {
999 return;
1000 }
1001
1002 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1003 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1004
1005 if (window && swapchain->frame_timestamps_enabled) {
1006 native_window_enable_frame_timestamps(window, false);
1007 }
1008
1009 for (uint32_t i = 0; i < swapchain->num_images; i++) {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001010 ReleaseSwapchainImage(device, window, -1, swapchain->images[i], false);
Yiwei Zhang533cea92019-06-03 18:43:24 -07001011 }
1012
1013 if (active) {
1014 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1015 }
1016
1017 if (!allocator) {
1018 allocator = &GetData(device).allocator;
1019 }
1020
1021 swapchain->~Swapchain();
1022 allocator->pfnFree(allocator->pUserData, swapchain);
1023}
1024
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001025VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001026VkResult CreateSwapchainKHR(VkDevice device,
1027 const VkSwapchainCreateInfoKHR* create_info,
1028 const VkAllocationCallbacks* allocator,
1029 VkSwapchainKHR* swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001030 ATRACE_CALL();
1031
Jesse Halld7b994a2015-09-07 14:17:37 -07001032 int err;
1033 VkResult result = VK_SUCCESS;
1034
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001035 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
1036 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
1037 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
1038 " oldSwapchain=0x%" PRIx64,
1039 reinterpret_cast<uint64_t>(create_info->surface),
1040 create_info->minImageCount, create_info->imageFormat,
1041 create_info->imageColorSpace, create_info->imageExtent.width,
1042 create_info->imageExtent.height, create_info->imageUsage,
1043 create_info->preTransform, create_info->presentMode,
1044 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1045
Jesse Hall1f91d392015-12-11 16:28:44 -08001046 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001047 allocator = &GetData(device).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -08001048
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -05001049 android::PixelFormat native_pixel_format =
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001050 GetNativePixelFormat(create_info->imageFormat);
1051 android_dataspace native_dataspace =
1052 GetNativeDataspace(create_info->imageColorSpace);
1053 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
1054 ALOGE(
1055 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
1056 "failed: Unsupported color space",
1057 create_info->imageColorSpace);
1058 return VK_ERROR_INITIALIZATION_FAILED;
1059 }
1060
Jesse Hall42a9eec2016-06-03 12:39:49 -07001061 ALOGV_IF(create_info->imageArrayLayers != 1,
Jesse Halldc225072016-05-30 22:40:14 -07001062 "swapchain imageArrayLayers=%u not supported",
Jesse Hall715b86a2016-01-16 16:34:29 -08001063 create_info->imageArrayLayers);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001064 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
Jesse Halldc225072016-05-30 22:40:14 -07001065 "swapchain preTransform=%#x not supported",
Jesse Hall55bc0972016-02-23 16:43:29 -08001066 create_info->preTransform);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001067 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
Chris Forbes980ad052017-01-18 16:55:07 +13001068 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
Chris Forbes1d5f68c2017-01-31 10:17:01 +13001069 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1070 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
Jesse Halldc225072016-05-30 22:40:14 -07001071 "swapchain presentMode=%u not supported",
Jesse Hall0ae0dce2016-02-09 22:13:34 -08001072 create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -07001073
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001074 Surface& surface = *SurfaceFromHandle(create_info->surface);
1075
Jesse Halldc225072016-05-30 22:40:14 -07001076 if (surface.swapchain_handle != create_info->oldSwapchain) {
Jesse Hall42a9eec2016-06-03 12:39:49 -07001077 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
Jesse Halldc225072016-05-30 22:40:14 -07001078 " because it already has active swapchain 0x%" PRIx64
1079 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
1080 reinterpret_cast<uint64_t>(create_info->surface),
1081 reinterpret_cast<uint64_t>(surface.swapchain_handle),
1082 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1083 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
1084 }
1085 if (create_info->oldSwapchain != VK_NULL_HANDLE)
1086 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
1087
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001088 // -- Reset the native window --
1089 // The native window might have been used previously, and had its properties
1090 // changed from defaults. That will affect the answer we get for queries
1091 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
1092 // attempt such queries.
1093
Jesse Halldc225072016-05-30 22:40:14 -07001094 // The native window only allows dequeueing all buffers before any have
1095 // been queued, since after that point at least one is assumed to be in
1096 // non-FREE state at any given time. Disconnecting and re-connecting
1097 // orphans the previous buffers, getting us back to the state where we can
1098 // dequeue all buffers.
Yiwei Zhang70a21962019-05-31 17:26:52 -07001099 //
1100 // TODO(http://b/134186185) recycle swapchain images more efficiently
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001101 ANativeWindow* window = surface.window.get();
1102 err = native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
1103 ALOGW_IF(err != android::OK, "native_window_api_disconnect failed: %s (%d)",
Jesse Halldc225072016-05-30 22:40:14 -07001104 strerror(-err), err);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001105 err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
1106 ALOGW_IF(err != android::OK, "native_window_api_connect failed: %s (%d)",
Jesse Halldc225072016-05-30 22:40:14 -07001107 strerror(-err), err);
1108
Nicolas Capens147b7da2021-04-09 14:53:06 -04001109 err =
1110 window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, nsecs_t{-1});
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001111 if (err != android::OK) {
1112 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1113 strerror(-err), err);
1114 return VK_ERROR_SURFACE_LOST_KHR;
1115 }
1116
Hrishikesh Manohar9b7e4532017-01-10 17:52:11 +05301117 int swap_interval =
1118 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001119 err = window->setSwapInterval(window, swap_interval);
1120 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001121 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
1122 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001123 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001124 }
1125
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001126 err = native_window_set_shared_buffer_mode(window, false);
1127 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001128 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
1129 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001130 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001131 }
1132
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001133 err = native_window_set_auto_refresh(window, false);
1134 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001135 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
1136 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001137 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001138 }
1139
Jesse Halld7b994a2015-09-07 14:17:37 -07001140 // -- Configure the native window --
Jesse Halld7b994a2015-09-07 14:17:37 -07001141
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001142 const auto& dispatch = GetData(device).driver;
Jesse Hall70f93352015-11-04 09:41:31 -08001143
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001144 err = native_window_set_buffers_format(window, native_pixel_format);
1145 if (err != android::OK) {
Leon Scroggins IIIcb45fe72021-11-30 16:17:15 -05001146 ALOGE("native_window_set_buffers_format(%s) failed: %s (%d)",
1147 decodePixelFormat(native_pixel_format).c_str(), strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001148 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001149 }
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001150 err = native_window_set_buffers_data_space(window, native_dataspace);
1151 if (err != android::OK) {
Jesse Hall517274a2016-02-10 00:07:18 -08001152 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001153 native_dataspace, strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001154 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001155 }
1156
Jesse Hall3dd678a2016-01-08 21:52:01 -08001157 err = native_window_set_buffers_dimensions(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001158 window, static_cast<int>(create_info->imageExtent.width),
Jesse Hall3dd678a2016-01-08 21:52:01 -08001159 static_cast<int>(create_info->imageExtent.height));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001160 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001161 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
1162 create_info->imageExtent.width, create_info->imageExtent.height,
1163 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001164 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001165 }
1166
Jesse Hall178b6962016-02-24 15:39:50 -08001167 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
1168 // applied during rendering. native_window_set_transform() expects the
1169 // inverse: the transform the app is requesting that the compositor perform
1170 // during composition. With native windows, pre-transform works by rendering
1171 // with the same transform the compositor is applying (as in Vulkan), but
1172 // then requesting the inverse transform, so that when the compositor does
1173 // it's job the two transforms cancel each other out and the compositor ends
1174 // up applying an identity transform to the app's buffer.
1175 err = native_window_set_buffers_transform(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001176 window, InvertTransformToNative(create_info->preTransform));
1177 if (err != android::OK) {
Jesse Hall178b6962016-02-24 15:39:50 -08001178 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
1179 InvertTransformToNative(create_info->preTransform),
1180 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001181 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall178b6962016-02-24 15:39:50 -08001182 }
1183
Jesse Hallf64ca122015-11-03 16:11:10 -08001184 err = native_window_set_scaling_mode(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001185 window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
1186 if (err != android::OK) {
Jesse Hallf64ca122015-11-03 16:11:10 -08001187 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
1188 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001189 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hallf64ca122015-11-03 16:11:10 -08001190 }
1191
Chris Forbes97ef4612017-03-30 19:37:50 +13001192 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
1193 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1194 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1195 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001196 err = native_window_set_shared_buffer_mode(window, true);
1197 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001198 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
1199 return VK_ERROR_SURFACE_LOST_KHR;
1200 }
1201 }
1202
1203 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001204 err = native_window_set_auto_refresh(window, true);
1205 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001206 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
1207 return VK_ERROR_SURFACE_LOST_KHR;
1208 }
1209 }
1210
Ian Elliott16c443c2021-11-30 17:10:32 -07001211 int query_value;
1212 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
1213 &query_value);
1214 if (err != android::OK || query_value < 0) {
1215 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
1216 query_value);
Mike Stroyan762c8132017-02-22 11:43:09 -07001217 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001218 }
Ian Elliott16c443c2021-11-30 17:10:32 -07001219 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
1220 const auto mailbox_num_images = std::max(3u, create_info->minImageCount);
1221 const auto requested_images =
1222 swap_interval ? create_info->minImageCount : mailbox_num_images;
1223 uint32_t num_images = requested_images - 1 + min_undequeued_buffers;
Chris Forbes2c8fc752017-03-17 11:28:32 +13001224
Ian Elliott5396b702021-12-13 19:32:34 -07001225 // Lower layer insists that we have at least min_undequeued_buffers + 1
1226 // buffers. This is wasteful and we'd like to relax it in the shared case,
1227 // but not all the pieces are in place for that to work yet. Note we only
1228 // lie to the lower layer--we don't want to give the app back a swapchain
1229 // with extra images (which they can't actually use!).
1230 uint32_t min_buffer_count = min_undequeued_buffers + 1;
1231 err = native_window_set_buffer_count(
1232 window, std::max(min_buffer_count, num_images));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001233 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001234 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
1235 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001236 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001237 }
1238
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001239 int32_t legacy_usage = 0;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001240 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
Jesse Halld1abd742017-02-09 21:45:51 -08001241 uint64_t consumer_usage, producer_usage;
Yiwei Zhang533cea92019-06-03 18:43:24 -07001242 ATRACE_BEGIN("GetSwapchainGrallocUsage2ANDROID");
Courtney Goeltzenleuchter894780b2017-04-03 16:11:30 -06001243 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1244 device, create_info->imageFormat, create_info->imageUsage,
1245 swapchain_image_usage, &consumer_usage, &producer_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001246 ATRACE_END();
Chris Forbes8c47dc92017-01-12 11:13:58 +13001247 if (result != VK_SUCCESS) {
1248 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001249 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001250 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001251 legacy_usage =
Jesse Hall79927812017-03-23 11:03:23 -07001252 android_convertGralloc1To0Usage(producer_usage, consumer_usage);
Chris Forbes8c47dc92017-01-12 11:13:58 +13001253 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001254 ATRACE_BEGIN("GetSwapchainGrallocUsageANDROID");
Jesse Hall1f91d392015-12-11 16:28:44 -08001255 result = dispatch.GetSwapchainGrallocUsageANDROID(
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001256 device, create_info->imageFormat, create_info->imageUsage,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001257 &legacy_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001258 ATRACE_END();
Jesse Hall70f93352015-11-04 09:41:31 -08001259 if (result != VK_SUCCESS) {
1260 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001261 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001262 }
Jesse Hall70f93352015-11-04 09:41:31 -08001263 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001264 uint64_t native_usage = static_cast<uint64_t>(legacy_usage);
1265
1266 bool createProtectedSwapchain = false;
1267 if (create_info->flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
1268 createProtectedSwapchain = true;
1269 native_usage |= BufferUsage::PROTECTED;
1270 }
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001271 err = native_window_set_usage(window, native_usage);
1272 if (err != android::OK) {
Jesse Hall70f93352015-11-04 09:41:31 -08001273 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001274 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001275 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001276
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001277 int transform_hint;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001278 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
1279 if (err != android::OK) {
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001280 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1281 strerror(-err), err);
1282 return VK_ERROR_SURFACE_LOST_KHR;
1283 }
1284
Jesse Halld7b994a2015-09-07 14:17:37 -07001285 // -- Allocate our Swapchain object --
1286 // After this point, we must deallocate the swapchain on error.
1287
Jesse Hall1f91d392015-12-11 16:28:44 -08001288 void* mem = allocator->pfnAllocation(allocator->pUserData,
1289 sizeof(Swapchain), alignof(Swapchain),
1290 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001291 if (!mem)
Jesse Halld7b994a2015-09-07 14:17:37 -07001292 return VK_ERROR_OUT_OF_HOST_MEMORY;
silence_dogood73597592019-05-23 16:57:37 -07001293 Swapchain* swapchain = new (mem)
1294 Swapchain(surface, num_images, create_info->presentMode,
1295 TranslateVulkanToNativeTransform(create_info->preTransform));
Jesse Halld7b994a2015-09-07 14:17:37 -07001296 // -- Dequeue all buffers and create a VkImage for each --
1297 // Any failures during or after this must cancel the dequeued buffers.
1298
Chris Forbesb56287a2017-01-12 14:28:58 +13001299 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1300#pragma clang diagnostic push
1301#pragma clang diagnostic ignored "-Wold-style-cast"
1302 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1303#pragma clang diagnostic pop
1304 .pNext = nullptr,
1305 .usage = swapchain_image_usage,
1306 };
Jesse Halld7b994a2015-09-07 14:17:37 -07001307 VkNativeBufferANDROID image_native_buffer = {
Jesse Halld7b994a2015-09-07 14:17:37 -07001308#pragma clang diagnostic push
1309#pragma clang diagnostic ignored "-Wold-style-cast"
1310 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1311#pragma clang diagnostic pop
Chris Forbesb56287a2017-01-12 14:28:58 +13001312 .pNext = &swapchain_image_create,
Jesse Halld7b994a2015-09-07 14:17:37 -07001313 };
1314 VkImageCreateInfo image_create = {
1315 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1316 .pNext = &image_native_buffer,
Nick Desaulnierse745a3e2019-10-18 10:38:45 -07001317 .flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
Jesse Halld7b994a2015-09-07 14:17:37 -07001318 .imageType = VK_IMAGE_TYPE_2D,
Jesse Hall517274a2016-02-10 00:07:18 -08001319 .format = create_info->imageFormat,
Jesse Halld7b994a2015-09-07 14:17:37 -07001320 .extent = {0, 0, 1},
1321 .mipLevels = 1,
Jesse Halla15a4bf2015-11-19 22:48:02 -08001322 .arrayLayers = 1,
Jesse Hall091ed9e2015-11-30 00:55:29 -08001323 .samples = VK_SAMPLE_COUNT_1_BIT,
Jesse Halld7b994a2015-09-07 14:17:37 -07001324 .tiling = VK_IMAGE_TILING_OPTIMAL,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001325 .usage = create_info->imageUsage,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001326 .sharingMode = create_info->imageSharingMode,
Jesse Hall03b6fe12015-11-24 12:44:21 -08001327 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
Jesse Halld7b994a2015-09-07 14:17:37 -07001328 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1329 };
1330
Jesse Halld7b994a2015-09-07 14:17:37 -07001331 for (uint32_t i = 0; i < num_images; i++) {
1332 Swapchain::Image& img = swapchain->images[i];
1333
1334 ANativeWindowBuffer* buffer;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001335 err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
1336 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001337 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
Yiwei Zhang702beb42019-11-29 17:59:55 -08001338 switch (-err) {
1339 case ENOMEM:
1340 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
1341 break;
1342 default:
1343 result = VK_ERROR_SURFACE_LOST_KHR;
1344 break;
1345 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001346 break;
1347 }
Chia-I Wue8e689f2016-04-18 08:21:31 +08001348 img.buffer = buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -07001349 img.dequeued = true;
1350
1351 image_create.extent =
Jesse Hall3dd678a2016-01-08 21:52:01 -08001352 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1353 static_cast<uint32_t>(img.buffer->height),
1354 1};
Jesse Halld7b994a2015-09-07 14:17:37 -07001355 image_native_buffer.handle = img.buffer->handle;
1356 image_native_buffer.stride = img.buffer->stride;
1357 image_native_buffer.format = img.buffer->format;
Mathias Agopiancb496ac2017-05-22 14:21:00 -07001358 image_native_buffer.usage = int(img.buffer->usage);
Chris Forbes8e0c3f52017-05-19 14:47:29 -07001359 android_convertGralloc0To1Usage(int(img.buffer->usage),
1360 &image_native_buffer.usage2.producer,
1361 &image_native_buffer.usage2.consumer);
Jesse Halld7b994a2015-09-07 14:17:37 -07001362
Yiwei Zhang533cea92019-06-03 18:43:24 -07001363 ATRACE_BEGIN("CreateImage");
Jesse Hall03b6fe12015-11-24 12:44:21 -08001364 result =
Jesse Hall1f91d392015-12-11 16:28:44 -08001365 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001366 ATRACE_END();
Jesse Halld7b994a2015-09-07 14:17:37 -07001367 if (result != VK_SUCCESS) {
1368 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1369 break;
1370 }
1371 }
1372
1373 // -- Cancel all buffers, returning them to the queue --
1374 // If an error occurred before, also destroy the VkImage and release the
1375 // buffer reference. Otherwise, we retain a strong reference to the buffer.
Chris Forbes31b85c22018-05-29 15:03:28 -07001376 for (uint32_t i = 0; i < num_images; i++) {
1377 Swapchain::Image& img = swapchain->images[i];
1378 if (img.dequeued) {
1379 if (!swapchain->shared) {
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001380 window->cancelBuffer(window, img.buffer.get(),
1381 img.dequeue_fence);
Chris Forbese0ced032017-03-30 19:44:15 +13001382 img.dequeue_fence = -1;
1383 img.dequeued = false;
1384 }
Chris Forbes31b85c22018-05-29 15:03:28 -07001385 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001386 }
1387
1388 if (result != VK_SUCCESS) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001389 DestroySwapchainInternal(device, HandleFromSwapchain(swapchain),
1390 allocator);
Jesse Halld7b994a2015-09-07 14:17:37 -07001391 return result;
1392 }
1393
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001394 if (transform_hint != swapchain->pre_transform) {
1395 // Log that the app is not doing pre-rotation.
1396 android::GraphicsEnv::getInstance().setTargetStats(
1397 android::GpuStatsInfo::Stats::FALSE_PREROTATION);
1398 }
1399
Jesse Halldc225072016-05-30 22:40:14 -07001400 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1401 *swapchain_handle = surface.swapchain_handle;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001402 return VK_SUCCESS;
1403}
1404
Jesse Halle1b12782015-11-30 11:27:32 -08001405VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001406void DestroySwapchainKHR(VkDevice device,
1407 VkSwapchainKHR swapchain_handle,
1408 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001409 ATRACE_CALL();
1410
Yiwei Zhang533cea92019-06-03 18:43:24 -07001411 DestroySwapchainInternal(device, swapchain_handle, allocator);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001412}
1413
Jesse Halle1b12782015-11-30 11:27:32 -08001414VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001415VkResult GetSwapchainImagesKHR(VkDevice,
1416 VkSwapchainKHR swapchain_handle,
1417 uint32_t* count,
1418 VkImage* images) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001419 ATRACE_CALL();
1420
Jesse Halld7b994a2015-09-07 14:17:37 -07001421 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Halldc225072016-05-30 22:40:14 -07001422 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1423 "getting images for non-active swapchain 0x%" PRIx64
1424 "; only dequeued image handles are valid",
1425 reinterpret_cast<uint64_t>(swapchain_handle));
Jesse Halld7b994a2015-09-07 14:17:37 -07001426 VkResult result = VK_SUCCESS;
1427 if (images) {
1428 uint32_t n = swapchain.num_images;
1429 if (*count < swapchain.num_images) {
1430 n = *count;
1431 result = VK_INCOMPLETE;
1432 }
1433 for (uint32_t i = 0; i < n; i++)
1434 images[i] = swapchain.images[i].image;
Jesse Hall7331e222016-09-15 21:26:01 -07001435 *count = n;
1436 } else {
1437 *count = swapchain.num_images;
Jesse Halld7b994a2015-09-07 14:17:37 -07001438 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001439 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001440}
1441
Jesse Halle1b12782015-11-30 11:27:32 -08001442VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001443VkResult AcquireNextImageKHR(VkDevice device,
1444 VkSwapchainKHR swapchain_handle,
1445 uint64_t timeout,
1446 VkSemaphore semaphore,
1447 VkFence vk_fence,
1448 uint32_t* image_index) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001449 ATRACE_CALL();
1450
Jesse Halld7b994a2015-09-07 14:17:37 -07001451 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001452 ANativeWindow* window = swapchain.surface.window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -07001453 VkResult result;
1454 int err;
1455
Jesse Halldc225072016-05-30 22:40:14 -07001456 if (swapchain.surface.swapchain_handle != swapchain_handle)
1457 return VK_ERROR_OUT_OF_DATE_KHR;
1458
Chris Forbesc88409c2017-03-30 19:47:37 +13001459 if (swapchain.shared) {
1460 // In shared mode, we keep the buffer dequeued all the time, so we don't
1461 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1462 // the semaphore and fence passed to us will be signalled.
1463 *image_index = 0;
1464 result = GetData(device).driver.AcquireImageANDROID(
1465 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1466 return result;
1467 }
1468
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001469 const nsecs_t acquire_next_image_timeout =
1470 timeout > (uint64_t)std::numeric_limits<nsecs_t>::max() ? -1 : timeout;
1471 if (acquire_next_image_timeout != swapchain.acquire_next_image_timeout) {
1472 // Cache the timeout to avoid the duplicate binder cost.
1473 err = window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT,
1474 acquire_next_image_timeout);
1475 if (err != android::OK) {
1476 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1477 strerror(-err), err);
1478 return VK_ERROR_SURFACE_LOST_KHR;
1479 }
1480 swapchain.acquire_next_image_timeout = acquire_next_image_timeout;
1481 }
1482
Jesse Halld7b994a2015-09-07 14:17:37 -07001483 ANativeWindowBuffer* buffer;
Jesse Hall06193802015-12-03 16:12:51 -08001484 int fence_fd;
1485 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Yiwei Zhangc0f8a2c2020-04-30 20:23:13 -07001486 if (err == android::TIMED_OUT || err == android::INVALID_OPERATION) {
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001487 ALOGW("dequeueBuffer timed out: %s (%d)", strerror(-err), err);
1488 return timeout ? VK_TIMEOUT : VK_NOT_READY;
1489 } else if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001490 ALOGE("dequeueBuffer failed: %s (%d)", 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
1494 uint32_t idx;
1495 for (idx = 0; idx < swapchain.num_images; idx++) {
1496 if (swapchain.images[idx].buffer.get() == buffer) {
1497 swapchain.images[idx].dequeued = true;
Jesse Hall06193802015-12-03 16:12:51 -08001498 swapchain.images[idx].dequeue_fence = fence_fd;
Jesse Halld7b994a2015-09-07 14:17:37 -07001499 break;
1500 }
1501 }
1502 if (idx == swapchain.num_images) {
1503 ALOGE("dequeueBuffer returned unrecognized buffer");
Jesse Hall06193802015-12-03 16:12:51 -08001504 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001505 return VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001506 }
1507
1508 int fence_clone = -1;
Jesse Hall06193802015-12-03 16:12:51 -08001509 if (fence_fd != -1) {
1510 fence_clone = dup(fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001511 if (fence_clone == -1) {
1512 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1513 strerror(errno), errno);
Jesse Hall06193802015-12-03 16:12:51 -08001514 sync_wait(fence_fd, -1 /* forever */);
Jesse Halld7b994a2015-09-07 14:17:37 -07001515 }
1516 }
1517
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001518 result = GetData(device).driver.AcquireImageANDROID(
Jesse Hall1f91d392015-12-11 16:28:44 -08001519 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001520 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001521 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1522 // even if the call fails. We could close it ourselves on failure, but
1523 // that would create a race condition if the driver closes it on a
1524 // failure path: some other thread might create an fd with the same
1525 // number between the time the driver closes it and the time we close
1526 // it. We must assume one of: the driver *always* closes it even on
1527 // failure, or *never* closes it on failure.
Jesse Hall06193802015-12-03 16:12:51 -08001528 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001529 swapchain.images[idx].dequeued = false;
1530 swapchain.images[idx].dequeue_fence = -1;
1531 return result;
1532 }
1533
1534 *image_index = idx;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001535 return VK_SUCCESS;
1536}
1537
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001538VKAPI_ATTR
1539VkResult AcquireNextImage2KHR(VkDevice device,
1540 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1541 uint32_t* pImageIndex) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001542 ATRACE_CALL();
1543
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001544 return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
1545 pAcquireInfo->timeout, pAcquireInfo->semaphore,
1546 pAcquireInfo->fence, pImageIndex);
1547}
1548
Jesse Halldc225072016-05-30 22:40:14 -07001549static VkResult WorstPresentResult(VkResult a, VkResult b) {
1550 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1551 // (in spec version 1.0.14).
1552 static const VkResult kWorstToBest[] = {
1553 VK_ERROR_DEVICE_LOST,
1554 VK_ERROR_SURFACE_LOST_KHR,
1555 VK_ERROR_OUT_OF_DATE_KHR,
1556 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1557 VK_ERROR_OUT_OF_HOST_MEMORY,
1558 VK_SUBOPTIMAL_KHR,
1559 };
1560 for (auto result : kWorstToBest) {
1561 if (a == result || b == result)
1562 return result;
1563 }
1564 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1565 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1566 return a != VK_SUCCESS ? a : b;
1567}
1568
Jesse Halle1b12782015-11-30 11:27:32 -08001569VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001570VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001571 ATRACE_CALL();
1572
Jesse Halld7b994a2015-09-07 14:17:37 -07001573 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1574 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1575 present_info->sType);
Jesse Halld7b994a2015-09-07 14:17:37 -07001576
Jesse Halldc225072016-05-30 22:40:14 -07001577 VkDevice device = GetData(queue).driver_device;
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001578 const auto& dispatch = GetData(queue).driver;
Jesse Halld7b994a2015-09-07 14:17:37 -07001579 VkResult final_result = VK_SUCCESS;
Jesse Halldc225072016-05-30 22:40:14 -07001580
Ian Elliottcb351132016-12-13 10:30:40 -07001581 // Look at the pNext chain for supported extension structs:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001582 const VkPresentRegionsKHR* present_regions = nullptr;
1583 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001584 const VkPresentRegionsKHR* next =
1585 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1586 while (next) {
1587 switch (next->sType) {
1588 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1589 present_regions = next;
1590 break;
Ian Elliott14866bb2017-01-20 09:15:48 -07001591 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001592 present_times =
1593 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1594 break;
Ian Elliottcb351132016-12-13 10:30:40 -07001595 default:
1596 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1597 next->sType);
1598 break;
1599 }
1600 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1601 }
1602 ALOGV_IF(
1603 present_regions &&
1604 present_regions->swapchainCount != present_info->swapchainCount,
1605 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001606 ALOGV_IF(present_times &&
1607 present_times->swapchainCount != present_info->swapchainCount,
1608 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1609 "VkPresentInfo::swapchainCount");
Ian Elliottcb351132016-12-13 10:30:40 -07001610 const VkPresentRegionKHR* regions =
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001611 (present_regions) ? present_regions->pRegions : nullptr;
1612 const VkPresentTimeGOOGLE* times =
1613 (present_times) ? present_times->pTimes : nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001614 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001615 android_native_rect_t* rects = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001616 uint32_t nrects = 0;
1617
Jesse Halld7b994a2015-09-07 14:17:37 -07001618 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1619 Swapchain& swapchain =
Jesse Hall03b6fe12015-11-24 12:44:21 -08001620 *SwapchainFromHandle(present_info->pSwapchains[sc]);
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001621 uint32_t image_idx = present_info->pImageIndices[sc];
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001622 Swapchain::Image& img = swapchain.images[image_idx];
Ian Elliottffedb652017-02-14 10:58:30 -07001623 const VkPresentRegionKHR* region =
1624 (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001625 const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
Jesse Halldc225072016-05-30 22:40:14 -07001626 VkResult swapchain_result = VK_SUCCESS;
Jesse Halld7b994a2015-09-07 14:17:37 -07001627 VkResult result;
1628 int err;
1629
Jesse Halld7b994a2015-09-07 14:17:37 -07001630 int fence = -1;
Jesse Hall275d76c2016-01-08 22:39:16 -08001631 result = dispatch.QueueSignalReleaseImageANDROID(
1632 queue, present_info->waitSemaphoreCount,
1633 present_info->pWaitSemaphores, img.image, &fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001634 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001635 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
Jesse Halldc225072016-05-30 22:40:14 -07001636 swapchain_result = result;
Jesse Halld7b994a2015-09-07 14:17:37 -07001637 }
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001638 if (img.release_fence >= 0)
1639 close(img.release_fence);
1640 img.release_fence = fence < 0 ? -1 : dup(fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001641
Jesse Halldc225072016-05-30 22:40:14 -07001642 if (swapchain.surface.swapchain_handle ==
1643 present_info->pSwapchains[sc]) {
1644 ANativeWindow* window = swapchain.surface.window.get();
1645 if (swapchain_result == VK_SUCCESS) {
Ian Elliottcb351132016-12-13 10:30:40 -07001646 if (region) {
1647 // Process the incremental-present hint for this swapchain:
1648 uint32_t rcount = region->rectangleCount;
1649 if (rcount > nrects) {
1650 android_native_rect_t* new_rects =
1651 static_cast<android_native_rect_t*>(
1652 allocator->pfnReallocation(
1653 allocator->pUserData, rects,
1654 sizeof(android_native_rect_t) * rcount,
1655 alignof(android_native_rect_t),
1656 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1657 if (new_rects) {
1658 rects = new_rects;
1659 nrects = rcount;
1660 } else {
1661 rcount = 0; // Ignore the hint for this swapchain
1662 }
1663 }
1664 for (uint32_t r = 0; r < rcount; ++r) {
1665 if (region->pRectangles[r].layer > 0) {
1666 ALOGV(
1667 "vkQueuePresentKHR ignoring invalid layer "
1668 "(%u); using layer 0 instead",
1669 region->pRectangles[r].layer);
1670 }
1671 int x = region->pRectangles[r].offset.x;
1672 int y = region->pRectangles[r].offset.y;
1673 int width = static_cast<int>(
1674 region->pRectangles[r].extent.width);
1675 int height = static_cast<int>(
1676 region->pRectangles[r].extent.height);
1677 android_native_rect_t* cur_rect = &rects[r];
1678 cur_rect->left = x;
1679 cur_rect->top = y + height;
1680 cur_rect->right = x + width;
1681 cur_rect->bottom = y;
1682 }
1683 native_window_set_surface_damage(window, rects, rcount);
1684 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001685 if (time) {
1686 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001687 ALOGV(
1688 "Calling "
1689 "native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001690 native_window_enable_frame_timestamps(window, true);
1691 swapchain.frame_timestamps_enabled = true;
1692 }
Brian Anderson1049d1d2016-12-16 17:25:57 -08001693
1694 // Record the nativeFrameId so it can be later correlated to
1695 // this present.
1696 uint64_t nativeFrameId = 0;
1697 err = native_window_get_next_frame_id(
1698 window, &nativeFrameId);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001699 if (err != android::OK) {
Brian Anderson1049d1d2016-12-16 17:25:57 -08001700 ALOGE("Failed to get next native frame ID.");
1701 }
1702
1703 // Add a new timing record with the user's presentID and
1704 // the nativeFrameId.
Yiwei Zhang5e862202019-06-21 14:59:16 -07001705 swapchain.timing.emplace_back(time, nativeFrameId);
Brian Anderson1049d1d2016-12-16 17:25:57 -08001706 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
Yiwei Zhang5e862202019-06-21 14:59:16 -07001707 swapchain.timing.erase(swapchain.timing.begin());
Ian Elliott8a977262017-01-19 09:05:58 -07001708 }
1709 if (time->desiredPresentTime) {
1710 // Set the desiredPresentTime:
1711 ALOGV(
1712 "Calling "
1713 "native_window_set_buffers_timestamp(%" PRId64 ")",
1714 time->desiredPresentTime);
1715 native_window_set_buffers_timestamp(
1716 window,
1717 static_cast<int64_t>(time->desiredPresentTime));
1718 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001719 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001720
Jesse Halldc225072016-05-30 22:40:14 -07001721 err = window->queueBuffer(window, img.buffer.get(), fence);
1722 // queueBuffer always closes fence, even on error
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001723 if (err != android::OK) {
Jesse Halldc225072016-05-30 22:40:14 -07001724 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1725 swapchain_result = WorstPresentResult(
Yiwei Zhang492dd5f2021-03-09 22:54:38 +00001726 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhang0b468472019-06-03 18:57:19 -07001727 } else {
1728 if (img.dequeue_fence >= 0) {
1729 close(img.dequeue_fence);
1730 img.dequeue_fence = -1;
1731 }
1732 img.dequeued = false;
Jesse Halldc225072016-05-30 22:40:14 -07001733 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001734
1735 // If the swapchain is in shared mode, immediately dequeue the
1736 // buffer so it can be presented again without an intervening
1737 // call to AcquireNextImageKHR. We expect to get the same buffer
1738 // back from every call to dequeueBuffer in this mode.
1739 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
1740 ANativeWindowBuffer* buffer;
1741 int fence_fd;
1742 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001743 if (err != android::OK) {
Chris Forbesfca0f292017-03-30 19:48:39 +13001744 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1745 swapchain_result = WorstPresentResult(swapchain_result,
1746 VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001747 } else if (img.buffer != buffer) {
Chris Forbesfca0f292017-03-30 19:48:39 +13001748 ALOGE("got wrong image back for shared swapchain");
1749 swapchain_result = WorstPresentResult(swapchain_result,
1750 VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001751 } else {
Chris Forbesfca0f292017-03-30 19:48:39 +13001752 img.dequeue_fence = fence_fd;
1753 img.dequeued = true;
1754 }
1755 }
Jesse Halldc225072016-05-30 22:40:14 -07001756 }
1757 if (swapchain_result != VK_SUCCESS) {
Jesse Halldc225072016-05-30 22:40:14 -07001758 OrphanSwapchain(device, &swapchain);
1759 }
silence_dogood73597592019-05-23 16:57:37 -07001760 int window_transform_hint;
1761 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
1762 &window_transform_hint);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001763 if (err != android::OK) {
silence_dogood73597592019-05-23 16:57:37 -07001764 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1765 strerror(-err), err);
1766 swapchain_result = WorstPresentResult(
1767 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
1768 }
1769 if (swapchain.pre_transform != window_transform_hint) {
1770 swapchain_result =
1771 WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
1772 }
Jesse Halldc225072016-05-30 22:40:14 -07001773 } else {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001774 ReleaseSwapchainImage(device, nullptr, fence, img, true);
Jesse Halldc225072016-05-30 22:40:14 -07001775 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001776 }
1777
Jesse Halla9e57032015-11-30 01:03:10 -08001778 if (present_info->pResults)
Jesse Halldc225072016-05-30 22:40:14 -07001779 present_info->pResults[sc] = swapchain_result;
1780
1781 if (swapchain_result != final_result)
1782 final_result = WorstPresentResult(final_result, swapchain_result);
Jesse Halld7b994a2015-09-07 14:17:37 -07001783 }
Ian Elliottcb351132016-12-13 10:30:40 -07001784 if (rects) {
1785 allocator->pfnFree(allocator->pUserData, rects);
1786 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001787
1788 return final_result;
1789}
Jesse Hallb1352bc2015-09-04 16:12:33 -07001790
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001791VKAPI_ATTR
1792VkResult GetRefreshCycleDurationGOOGLE(
1793 VkDevice,
Ian Elliott62c48c92017-01-20 13:13:20 -07001794 VkSwapchainKHR swapchain_handle,
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001795 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001796 ATRACE_CALL();
1797
Ian Elliott62c48c92017-01-20 13:13:20 -07001798 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001799 VkResult result = VK_SUCCESS;
1800
Ian Elliott3568bfe2019-05-03 15:54:46 -06001801 pDisplayTimingProperties->refreshDuration = swapchain.get_refresh_duration();
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001802
1803 return result;
1804}
1805
1806VKAPI_ATTR
1807VkResult GetPastPresentationTimingGOOGLE(
1808 VkDevice,
1809 VkSwapchainKHR swapchain_handle,
1810 uint32_t* count,
1811 VkPastPresentationTimingGOOGLE* timings) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001812 ATRACE_CALL();
1813
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001814 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001815 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1816 return VK_ERROR_OUT_OF_DATE_KHR;
1817 }
1818
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001819 ANativeWindow* window = swapchain.surface.window.get();
1820 VkResult result = VK_SUCCESS;
1821
1822 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001823 ALOGV("Calling native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001824 native_window_enable_frame_timestamps(window, true);
1825 swapchain.frame_timestamps_enabled = true;
1826 }
1827
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001828 if (timings) {
Yiwei Zhang9d187832019-07-22 15:15:47 -07001829 // Get the latest ready timing count before copying, since the copied
1830 // timing info will be erased in copy_ready_timings function.
1831 uint32_t n = get_num_ready_timings(swapchain);
Ian Elliott8a977262017-01-19 09:05:58 -07001832 copy_ready_timings(swapchain, count, timings);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001833 // Check the *count here against the recorded ready timing count, since
1834 // *count can be overwritten per spec describes.
1835 if (*count < n) {
1836 result = VK_INCOMPLETE;
1837 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001838 } else {
Ian Elliott8a977262017-01-19 09:05:58 -07001839 *count = get_num_ready_timings(swapchain);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001840 }
1841
1842 return result;
1843}
1844
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001845VKAPI_ATTR
1846VkResult GetSwapchainStatusKHR(
1847 VkDevice,
Chris Forbes4e18ba82017-01-20 12:50:17 +13001848 VkSwapchainKHR swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001849 ATRACE_CALL();
1850
Chris Forbes4e18ba82017-01-20 12:50:17 +13001851 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001852 VkResult result = VK_SUCCESS;
1853
Chris Forbes4e18ba82017-01-20 12:50:17 +13001854 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1855 return VK_ERROR_OUT_OF_DATE_KHR;
1856 }
1857
Yiwei Zhanga885c062019-10-24 12:07:57 -07001858 // TODO(b/143296009): Implement this function properly
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001859
1860 return result;
1861}
1862
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001863VKAPI_ATTR void SetHdrMetadataEXT(
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001864 VkDevice,
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001865 uint32_t swapchainCount,
1866 const VkSwapchainKHR* pSwapchains,
1867 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001868 ATRACE_CALL();
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001869
1870 for (uint32_t idx = 0; idx < swapchainCount; idx++) {
1871 Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);
1872 if (!swapchain)
1873 continue;
1874
1875 if (swapchain->surface.swapchain_handle != pSwapchains[idx]) continue;
1876
1877 ANativeWindow* window = swapchain->surface.window.get();
1878
1879 VkHdrMetadataEXT vulkanMetadata = pHdrMetadataEXTs[idx];
1880 const android_smpte2086_metadata smpteMetdata = {
1881 {vulkanMetadata.displayPrimaryRed.x,
1882 vulkanMetadata.displayPrimaryRed.y},
1883 {vulkanMetadata.displayPrimaryGreen.x,
1884 vulkanMetadata.displayPrimaryGreen.y},
1885 {vulkanMetadata.displayPrimaryBlue.x,
1886 vulkanMetadata.displayPrimaryBlue.y},
1887 {vulkanMetadata.whitePoint.x, vulkanMetadata.whitePoint.y},
1888 vulkanMetadata.maxLuminance,
1889 vulkanMetadata.minLuminance};
1890 native_window_set_buffers_smpte2086_metadata(window, &smpteMetdata);
1891
1892 const android_cta861_3_metadata cta8613Metadata = {
1893 vulkanMetadata.maxContentLightLevel,
1894 vulkanMetadata.maxFrameAverageLightLevel};
1895 native_window_set_buffers_cta861_3_metadata(window, &cta8613Metadata);
1896 }
1897
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001898 return;
1899}
1900
Yiwei Zhang0f475222019-04-11 19:38:00 -07001901static void InterceptBindImageMemory2(
1902 uint32_t bind_info_count,
1903 const VkBindImageMemoryInfo* bind_infos,
1904 std::vector<VkNativeBufferANDROID>* out_native_buffers,
1905 std::vector<VkBindImageMemoryInfo>* out_bind_infos) {
1906 out_native_buffers->clear();
1907 out_bind_infos->clear();
1908
1909 if (!bind_info_count)
1910 return;
1911
1912 std::unordered_set<uint32_t> intercepted_indexes;
1913
1914 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1915 auto info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1916 bind_infos[idx].pNext);
1917 while (info &&
1918 info->sType !=
1919 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR) {
1920 info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1921 info->pNext);
1922 }
1923
1924 if (!info)
1925 continue;
1926
1927 ALOG_ASSERT(info->swapchain != VK_NULL_HANDLE,
1928 "swapchain handle must not be NULL");
1929 const Swapchain* swapchain = SwapchainFromHandle(info->swapchain);
1930 ALOG_ASSERT(
1931 info->imageIndex < swapchain->num_images,
1932 "imageIndex must be less than the number of images in swapchain");
1933
1934 ANativeWindowBuffer* buffer =
1935 swapchain->images[info->imageIndex].buffer.get();
1936 VkNativeBufferANDROID native_buffer = {
1937#pragma clang diagnostic push
1938#pragma clang diagnostic ignored "-Wold-style-cast"
1939 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1940#pragma clang diagnostic pop
1941 .pNext = bind_infos[idx].pNext,
1942 .handle = buffer->handle,
1943 .stride = buffer->stride,
1944 .format = buffer->format,
1945 .usage = int(buffer->usage),
1946 };
1947 // Reserve enough space to avoid letting re-allocation invalidate the
1948 // addresses of the elements inside.
1949 out_native_buffers->reserve(bind_info_count);
1950 out_native_buffers->emplace_back(native_buffer);
1951
1952 // Reserve the space now since we know how much is needed now.
1953 out_bind_infos->reserve(bind_info_count);
1954 out_bind_infos->emplace_back(bind_infos[idx]);
1955 out_bind_infos->back().pNext = &out_native_buffers->back();
1956
1957 intercepted_indexes.insert(idx);
1958 }
1959
1960 if (intercepted_indexes.empty())
1961 return;
1962
1963 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1964 if (intercepted_indexes.count(idx))
1965 continue;
1966 out_bind_infos->emplace_back(bind_infos[idx]);
1967 }
1968}
1969
Yiwei Zhang23143102019-04-10 18:24:05 -07001970VKAPI_ATTR
1971VkResult BindImageMemory2(VkDevice device,
1972 uint32_t bindInfoCount,
1973 const VkBindImageMemoryInfo* pBindInfos) {
1974 ATRACE_CALL();
1975
Yiwei Zhang0f475222019-04-11 19:38:00 -07001976 // out_native_buffers is for maintaining the lifecycle of the constructed
1977 // VkNativeBufferANDROID objects inside InterceptBindImageMemory2.
1978 std::vector<VkNativeBufferANDROID> out_native_buffers;
1979 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1980 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1981 &out_bind_infos);
1982 return GetData(device).driver.BindImageMemory2(
1983 device, bindInfoCount,
1984 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07001985}
1986
1987VKAPI_ATTR
1988VkResult BindImageMemory2KHR(VkDevice device,
1989 uint32_t bindInfoCount,
1990 const VkBindImageMemoryInfo* pBindInfos) {
1991 ATRACE_CALL();
1992
Yiwei Zhang0f475222019-04-11 19:38:00 -07001993 std::vector<VkNativeBufferANDROID> out_native_buffers;
1994 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1995 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1996 &out_bind_infos);
1997 return GetData(device).driver.BindImageMemory2KHR(
1998 device, bindInfoCount,
1999 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07002000}
2001
Chia-I Wu62262232016-03-26 07:06:44 +08002002} // namespace driver
Jesse Hallb1352bc2015-09-04 16:12:33 -07002003} // namespace vulkan