blob: b6a1199532e2fe54f6a5297a31128b9d1a87def0 [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>
Chia-I Wue8e689f2016-04-18 08:21:31 +080026#include <utils/StrongPointer.h>
Yiwei Zhang705c2e62019-12-18 23:12:43 -080027#include <utils/Timers.h>
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -080028#include <utils/Trace.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070029
30#include <algorithm>
31#include <unordered_set>
32#include <vector>
Jesse Halld7b994a2015-09-07 14:17:37 -070033
Chia-I Wu4a6a9162016-03-26 07:17:34 +080034#include "driver.h"
Jesse Halld7b994a2015-09-07 14:17:37 -070035
Daniel Kochf25f5bb2017-10-05 00:26:58 -040036using android::hardware::graphics::common::V1_0::BufferUsage;
37
Chia-I Wu62262232016-03-26 07:06:44 +080038namespace vulkan {
39namespace driver {
Jesse Hall5ae3abb2015-10-08 14:00:22 -070040
Jesse Halld7b994a2015-09-07 14:17:37 -070041namespace {
42
Jesse Hall55bc0972016-02-23 16:43:29 -080043const VkSurfaceTransformFlagsKHR kSupportedTransforms =
44 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
45 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
46 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
47 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
Yiwei Zhang70a21962019-05-31 17:26:52 -070048 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
49 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
50 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
51 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
Jesse Hall55bc0972016-02-23 16:43:29 -080052 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
53
54VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
55 // Native and Vulkan transforms are isomorphic, but are represented
56 // differently. Vulkan transforms are built up of an optional horizontal
57 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
58 // transforms are built up from a horizontal flip, vertical flip, and
59 // 90-degree rotation, all optional but always in that order.
60
Jesse Hall55bc0972016-02-23 16:43:29 -080061 switch (native) {
Yiwei Zhang70a21962019-05-31 17:26:52 -070062 case 0:
Jesse Hall55bc0972016-02-23 16:43:29 -080063 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070064 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
65 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
66 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
67 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
68 case NATIVE_WINDOW_TRANSFORM_ROT_180:
Jesse Hall55bc0972016-02-23 16:43:29 -080069 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070070 case NATIVE_WINDOW_TRANSFORM_ROT_90:
Jesse Hall55bc0972016-02-23 16:43:29 -080071 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070072 case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
73 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
74 case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
75 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
76 case NATIVE_WINDOW_TRANSFORM_ROT_270:
Jesse Hall55bc0972016-02-23 16:43:29 -080077 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
78 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
79 default:
80 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
81 }
82}
83
Yiwei Zhang70a21962019-05-31 17:26:52 -070084int TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform) {
85 switch (transform) {
86 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
87 return NATIVE_WINDOW_TRANSFORM_ROT_90;
88 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
89 return NATIVE_WINDOW_TRANSFORM_ROT_180;
90 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
91 return NATIVE_WINDOW_TRANSFORM_ROT_270;
92 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
93 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
94 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
95 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
96 NATIVE_WINDOW_TRANSFORM_ROT_90;
97 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
98 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
99 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
100 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
101 NATIVE_WINDOW_TRANSFORM_ROT_90;
102 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
103 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
104 default:
105 return 0;
106 }
107}
108
Jesse Hall178b6962016-02-24 15:39:50 -0800109int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
110 switch (transform) {
111 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
112 return NATIVE_WINDOW_TRANSFORM_ROT_270;
113 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
114 return NATIVE_WINDOW_TRANSFORM_ROT_180;
115 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
116 return NATIVE_WINDOW_TRANSFORM_ROT_90;
Yiwei Zhang70a21962019-05-31 17:26:52 -0700117 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
118 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
119 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
120 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
121 NATIVE_WINDOW_TRANSFORM_ROT_90;
122 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
123 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
124 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
125 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
126 NATIVE_WINDOW_TRANSFORM_ROT_90;
Jesse Hall178b6962016-02-24 15:39:50 -0800127 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
128 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
129 default:
130 return 0;
131 }
132}
133
Ian Elliott8a977262017-01-19 09:05:58 -0700134class TimingInfo {
135 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800136 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
Ian Elliott2c6355d2017-01-19 11:02:13 -0700137 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
Brian Anderson1049d1d2016-12-16 17:25:57 -0800138 native_frame_id_(nativeFrameId) {}
139 bool ready() const {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700140 return (timestamp_desired_present_time_ !=
141 NATIVE_WINDOW_TIMESTAMP_PENDING &&
142 timestamp_actual_present_time_ !=
143 NATIVE_WINDOW_TIMESTAMP_PENDING &&
144 timestamp_render_complete_time_ !=
145 NATIVE_WINDOW_TIMESTAMP_PENDING &&
146 timestamp_composition_latch_time_ !=
147 NATIVE_WINDOW_TIMESTAMP_PENDING);
Ian Elliott8a977262017-01-19 09:05:58 -0700148 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700149 void calculate(int64_t rdur) {
150 bool anyTimestampInvalid =
151 (timestamp_actual_present_time_ ==
152 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
153 (timestamp_render_complete_time_ ==
154 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
155 (timestamp_composition_latch_time_ ==
156 NATIVE_WINDOW_TIMESTAMP_INVALID);
157 if (anyTimestampInvalid) {
158 ALOGE("Unexpectedly received invalid timestamp.");
159 vals_.actualPresentTime = 0;
160 vals_.earliestPresentTime = 0;
161 vals_.presentMargin = 0;
162 return;
163 }
164
165 vals_.actualPresentTime =
166 static_cast<uint64_t>(timestamp_actual_present_time_);
167 int64_t margin = (timestamp_composition_latch_time_ -
Ian Elliott8a977262017-01-19 09:05:58 -0700168 timestamp_render_complete_time_);
169 // Calculate vals_.earliestPresentTime, and potentially adjust
170 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
171 // is vals_.actualPresentTime. If we can subtract rdur (the duration
172 // of a refresh cycle) from vals_.earliestPresentTime (and also from
173 // vals_.presentMargin) and still leave a positive margin, then we can
174 // report to the application that it could have presented earlier than
175 // it did (per the extension specification). If for some reason, we
176 // can do this subtraction repeatedly, we do, since
177 // vals_.earliestPresentTime really is supposed to be the "earliest".
Brian Andersondc96fdf2017-03-20 16:54:25 -0700178 int64_t early_time = timestamp_actual_present_time_;
Ian Elliott8a977262017-01-19 09:05:58 -0700179 while ((margin > rdur) &&
180 ((early_time - rdur) > timestamp_composition_latch_time_)) {
181 early_time -= rdur;
182 margin -= rdur;
183 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700184 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
185 vals_.presentMargin = static_cast<uint64_t>(margin);
Ian Elliott8a977262017-01-19 09:05:58 -0700186 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800187 void get_values(VkPastPresentationTimingGOOGLE* values) const {
188 *values = vals_;
189 }
Ian Elliott8a977262017-01-19 09:05:58 -0700190
191 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800192 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700193
Brian Anderson1049d1d2016-12-16 17:25:57 -0800194 uint64_t native_frame_id_ { 0 };
Brian Andersondc96fdf2017-03-20 16:54:25 -0700195 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
196 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
197 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
198 int64_t timestamp_composition_latch_time_
199 { NATIVE_WINDOW_TIMESTAMP_PENDING };
Ian Elliott8a977262017-01-19 09:05:58 -0700200};
201
Jesse Hall1356b0d2015-11-23 17:24:58 -0800202struct Surface {
Chia-I Wue8e689f2016-04-18 08:21:31 +0800203 android::sp<ANativeWindow> window;
Jesse Halldc225072016-05-30 22:40:14 -0700204 VkSwapchainKHR swapchain_handle;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700205 uint64_t consumer_usage;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800206};
207
208VkSurfaceKHR HandleFromSurface(Surface* surface) {
209 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
210}
211
212Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800213 return reinterpret_cast<Surface*>(handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800214}
215
Ian Elliott8a977262017-01-19 09:05:58 -0700216// Maximum number of TimingInfo structs to keep per swapchain:
217enum { MAX_TIMING_INFOS = 10 };
218// Minimum number of frames to look for in the past (so we don't cause
219// syncronous requests to Surface Flinger):
220enum { MIN_NUM_FRAMES_AGO = 5 };
221
Jesse Hall1356b0d2015-11-23 17:24:58 -0800222struct Swapchain {
Ian Elliottffedb652017-02-14 10:58:30 -0700223 Swapchain(Surface& surface_,
224 uint32_t num_images_,
silence_dogood73597592019-05-23 16:57:37 -0700225 VkPresentModeKHR present_mode,
226 int pre_transform_)
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700227 : surface(surface_),
228 num_images(num_images_),
Ian Elliottffedb652017-02-14 10:58:30 -0700229 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
silence_dogood73597592019-05-23 16:57:37 -0700230 pre_transform(pre_transform_),
Chris Forbesf8835642017-03-30 19:31:40 +1300231 frame_timestamps_enabled(false),
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800232 acquire_next_image_timeout(-1),
Chris Forbesf8835642017-03-30 19:31:40 +1300233 shared(present_mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800234 present_mode ==
235 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Ian Elliott62c48c92017-01-20 13:13:20 -0700236 ANativeWindow* window = surface.window.get();
Ian Elliottbe833a22017-01-25 13:09:20 -0700237 native_window_get_refresh_cycle_duration(
Ian Elliott62c48c92017-01-20 13:13:20 -0700238 window,
Brian Andersondc96fdf2017-03-20 16:54:25 -0700239 &refresh_duration);
Ian Elliott8a977262017-01-19 09:05:58 -0700240 }
Ian Elliott3568bfe2019-05-03 15:54:46 -0600241 uint64_t get_refresh_duration()
242 {
243 ANativeWindow* window = surface.window.get();
244 native_window_get_refresh_cycle_duration(
245 window,
246 &refresh_duration);
247 return static_cast<uint64_t>(refresh_duration);
248
249 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800250
251 Surface& surface;
Jesse Halld7b994a2015-09-07 14:17:37 -0700252 uint32_t num_images;
Ian Elliottffedb652017-02-14 10:58:30 -0700253 bool mailbox_mode;
silence_dogood73597592019-05-23 16:57:37 -0700254 int pre_transform;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700255 bool frame_timestamps_enabled;
Brian Andersondc96fdf2017-03-20 16:54:25 -0700256 int64_t refresh_duration;
Yiwei Zhang705c2e62019-12-18 23:12:43 -0800257 nsecs_t acquire_next_image_timeout;
Chris Forbesf8835642017-03-30 19:31:40 +1300258 bool shared;
Jesse Halld7b994a2015-09-07 14:17:37 -0700259
260 struct Image {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700261 Image()
262 : image(VK_NULL_HANDLE),
263 dequeue_fence(-1),
264 release_fence(-1),
265 dequeued(false) {}
Jesse Halld7b994a2015-09-07 14:17:37 -0700266 VkImage image;
Chia-I Wue8e689f2016-04-18 08:21:31 +0800267 android::sp<ANativeWindowBuffer> buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -0700268 // The fence is only valid when the buffer is dequeued, and should be
269 // -1 any other time. When valid, we own the fd, and must ensure it is
270 // closed: either by closing it explicitly when queueing the buffer,
271 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
272 int dequeue_fence;
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700273 // This fence is a dup of the sync fd returned from the driver via
274 // vkQueueSignalReleaseImageANDROID upon vkQueuePresentKHR. We must
275 // ensure it is closed upon re-presenting or releasing the image.
276 int release_fence;
Jesse Halld7b994a2015-09-07 14:17:37 -0700277 bool dequeued;
Pawin Vongmasa6e1193a2017-03-07 13:08:40 -0800278 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
Ian Elliott8a977262017-01-19 09:05:58 -0700279
Yiwei Zhang5e862202019-06-21 14:59:16 -0700280 std::vector<TimingInfo> timing;
Jesse Halld7b994a2015-09-07 14:17:37 -0700281};
282
283VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
284 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
285}
286
287Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800288 return reinterpret_cast<Swapchain*>(handle);
Jesse Halld7b994a2015-09-07 14:17:37 -0700289}
290
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700291static bool IsFencePending(int fd) {
292 if (fd < 0)
293 return false;
294
295 errno = 0;
296 return sync_wait(fd, 0 /* timeout */) == -1 && errno == ETIME;
297}
298
Jesse Halldc225072016-05-30 22:40:14 -0700299void ReleaseSwapchainImage(VkDevice device,
300 ANativeWindow* window,
301 int release_fence,
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700302 Swapchain::Image& image,
303 bool defer_if_pending) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700304 ATRACE_CALL();
305
Jesse Halldc225072016-05-30 22:40:14 -0700306 ALOG_ASSERT(release_fence == -1 || image.dequeued,
307 "ReleaseSwapchainImage: can't provide a release fence for "
308 "non-dequeued images");
309
310 if (image.dequeued) {
311 if (release_fence >= 0) {
312 // We get here from vkQueuePresentKHR. The application is
313 // responsible for creating an execution dependency chain from
314 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
315 // (release_fence), so we can drop the dequeue_fence here.
316 if (image.dequeue_fence >= 0)
317 close(image.dequeue_fence);
318 } else {
319 // We get here during swapchain destruction, or various serious
320 // error cases e.g. when we can't create the release_fence during
321 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
322 // have already signalled, since the swapchain images are supposed
323 // to be idle before the swapchain is destroyed. In error cases,
324 // there may be rendering in flight to the image, but since we
325 // weren't able to create a release_fence, waiting for the
326 // dequeue_fence is about the best we can do.
327 release_fence = image.dequeue_fence;
328 }
329 image.dequeue_fence = -1;
330
331 if (window) {
332 window->cancelBuffer(window, image.buffer.get(), release_fence);
333 } else {
334 if (release_fence >= 0) {
335 sync_wait(release_fence, -1 /* forever */);
336 close(release_fence);
337 }
338 }
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700339 release_fence = -1;
Jesse Halldc225072016-05-30 22:40:14 -0700340 image.dequeued = false;
341 }
342
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700343 if (defer_if_pending && IsFencePending(image.release_fence))
344 return;
345
346 if (image.release_fence >= 0) {
347 close(image.release_fence);
348 image.release_fence = -1;
349 }
350
Jesse Halldc225072016-05-30 22:40:14 -0700351 if (image.image) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700352 ATRACE_BEGIN("DestroyImage");
Jesse Halldc225072016-05-30 22:40:14 -0700353 GetData(device).driver.DestroyImage(device, image.image, nullptr);
Yiwei Zhang533cea92019-06-03 18:43:24 -0700354 ATRACE_END();
Jesse Halldc225072016-05-30 22:40:14 -0700355 image.image = VK_NULL_HANDLE;
356 }
357
358 image.buffer.clear();
359}
360
361void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
362 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
363 return;
Jesse Halldc225072016-05-30 22:40:14 -0700364 for (uint32_t i = 0; i < swapchain->num_images; i++) {
365 if (!swapchain->images[i].dequeued)
Yiwei Zhang9df5bff2020-09-22 10:08:03 -0700366 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i],
367 true);
Jesse Halldc225072016-05-30 22:40:14 -0700368 }
369 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Ian Elliott8a977262017-01-19 09:05:58 -0700370 swapchain->timing.clear();
371}
372
373uint32_t get_num_ready_timings(Swapchain& swapchain) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800374 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
375 return 0;
376 }
Ian Elliott8a977262017-01-19 09:05:58 -0700377
Brian Anderson1049d1d2016-12-16 17:25:57 -0800378 uint32_t num_ready = 0;
379 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
380 for (uint32_t i = 0; i < num_timings; i++) {
Yiwei Zhang5e862202019-06-21 14:59:16 -0700381 TimingInfo& ti = swapchain.timing[i];
Brian Anderson1049d1d2016-12-16 17:25:57 -0800382 if (ti.ready()) {
383 // This TimingInfo is ready to be reported to the user. Add it
384 // to the num_ready.
385 num_ready++;
386 continue;
387 }
388 // This TimingInfo is not yet ready to be reported to the user,
389 // and so we should look for any available timestamps that
390 // might make it ready.
391 int64_t desired_present_time = 0;
392 int64_t render_complete_time = 0;
393 int64_t composition_latch_time = 0;
394 int64_t actual_present_time = 0;
395 // Obtain timestamps:
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800396 int err = native_window_get_frame_timestamps(
Brian Anderson1049d1d2016-12-16 17:25:57 -0800397 swapchain.surface.window.get(), ti.native_frame_id_,
398 &desired_present_time, &render_complete_time,
399 &composition_latch_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700400 nullptr, //&first_composition_start_time,
401 nullptr, //&last_composition_start_time,
402 nullptr, //&composition_finish_time,
Brian Anderson1049d1d2016-12-16 17:25:57 -0800403 &actual_present_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700404 nullptr, //&dequeue_ready_time,
405 nullptr /*&reads_done_time*/);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800406
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800407 if (err != android::OK) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800408 continue;
409 }
410
411 // Record the timestamp(s) we received, and then see if this TimingInfo
412 // is ready to be reported to the user:
Brian Andersondc96fdf2017-03-20 16:54:25 -0700413 ti.timestamp_desired_present_time_ = desired_present_time;
414 ti.timestamp_actual_present_time_ = actual_present_time;
415 ti.timestamp_render_complete_time_ = render_complete_time;
416 ti.timestamp_composition_latch_time_ = composition_latch_time;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800417
418 if (ti.ready()) {
419 // The TimingInfo has received enough timestamps, and should now
420 // use those timestamps to calculate the info that should be
421 // reported to the user:
422 ti.calculate(swapchain.refresh_duration);
423 num_ready++;
Ian Elliott8a977262017-01-19 09:05:58 -0700424 }
425 }
426 return num_ready;
427}
428
Ian Elliott8a977262017-01-19 09:05:58 -0700429void copy_ready_timings(Swapchain& swapchain,
430 uint32_t* count,
431 VkPastPresentationTimingGOOGLE* timings) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800432 if (swapchain.timing.empty()) {
433 *count = 0;
434 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700435 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800436
437 size_t last_ready = swapchain.timing.size() - 1;
438 while (!swapchain.timing[last_ready].ready()) {
439 if (last_ready == 0) {
440 *count = 0;
441 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700442 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800443 last_ready--;
Ian Elliott8a977262017-01-19 09:05:58 -0700444 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800445
446 uint32_t num_copied = 0;
Yiwei Zhang5e862202019-06-21 14:59:16 -0700447 int32_t num_to_remove = 0;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800448 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
449 const TimingInfo& ti = swapchain.timing[i];
450 if (ti.ready()) {
451 ti.get_values(&timings[num_copied]);
452 num_copied++;
453 }
454 num_to_remove++;
455 }
456
457 // Discard old frames that aren't ready if newer frames are ready.
458 // We don't expect to get the timing info for those old frames.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700459 swapchain.timing.erase(swapchain.timing.begin(),
460 swapchain.timing.begin() + num_to_remove);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800461
Ian Elliott8a977262017-01-19 09:05:58 -0700462 *count = num_copied;
Jesse Halldc225072016-05-30 22:40:14 -0700463}
464
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700465android_pixel_format GetNativePixelFormat(VkFormat format) {
466 android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
467 switch (format) {
468 case VK_FORMAT_R8G8B8A8_UNORM:
469 case VK_FORMAT_R8G8B8A8_SRGB:
470 native_format = HAL_PIXEL_FORMAT_RGBA_8888;
471 break;
472 case VK_FORMAT_R5G6B5_UNORM_PACK16:
473 native_format = HAL_PIXEL_FORMAT_RGB_565;
474 break;
475 case VK_FORMAT_R16G16B16A16_SFLOAT:
476 native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
477 break;
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800478 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700479 native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
480 break;
481 default:
482 ALOGV("unsupported swapchain format %d", format);
483 break;
484 }
485 return native_format;
486}
487
488android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
489 switch (colorspace) {
490 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
491 return HAL_DATASPACE_V0_SRGB;
492 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
493 return HAL_DATASPACE_DISPLAY_P3;
494 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
495 return HAL_DATASPACE_V0_SCRGB_LINEAR;
Courtney Goeltzenleuchterb52abee2017-08-07 17:13:04 -0600496 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
497 return HAL_DATASPACE_V0_SCRGB;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700498 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
499 return HAL_DATASPACE_DCI_P3_LINEAR;
500 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
501 return HAL_DATASPACE_DCI_P3;
502 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
503 return HAL_DATASPACE_V0_SRGB_LINEAR;
504 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
505 return HAL_DATASPACE_V0_SRGB;
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600506 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
507 return HAL_DATASPACE_BT2020_LINEAR;
508 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700509 return static_cast<android_dataspace>(
510 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
511 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600512 case VK_COLOR_SPACE_DOLBYVISION_EXT:
513 return static_cast<android_dataspace>(
514 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
515 HAL_DATASPACE_RANGE_FULL);
516 case VK_COLOR_SPACE_HDR10_HLG_EXT:
517 return static_cast<android_dataspace>(
518 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_HLG |
519 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700520 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
521 return static_cast<android_dataspace>(
522 HAL_DATASPACE_STANDARD_ADOBE_RGB |
523 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
524 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
525 return HAL_DATASPACE_ADOBE_RGB;
526
527 // Pass through is intended to allow app to provide data that is passed
528 // to the display system without modification.
529 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
530 return HAL_DATASPACE_ARBITRARY;
531
532 default:
533 // This indicates that we don't know about the
534 // dataspace specified and we should indicate that
535 // it's unsupported
536 return HAL_DATASPACE_UNKNOWN;
537 }
538}
539
Jesse Halld7b994a2015-09-07 14:17:37 -0700540} // anonymous namespace
Jesse Hallb1352bc2015-09-04 16:12:33 -0700541
Jesse Halle1b12782015-11-30 11:27:32 -0800542VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800543VkResult CreateAndroidSurfaceKHR(
Jesse Hallf9fa9a52016-01-08 16:08:51 -0800544 VkInstance instance,
545 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
546 const VkAllocationCallbacks* allocator,
547 VkSurfaceKHR* out_surface) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800548 ATRACE_CALL();
549
Jesse Hall1f91d392015-12-11 16:28:44 -0800550 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800551 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800552 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
553 alignof(Surface),
554 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800555 if (!mem)
556 return VK_ERROR_OUT_OF_HOST_MEMORY;
557 Surface* surface = new (mem) Surface;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700558
Chia-I Wue8e689f2016-04-18 08:21:31 +0800559 surface->window = pCreateInfo->window;
Jesse Halldc225072016-05-30 22:40:14 -0700560 surface->swapchain_handle = VK_NULL_HANDLE;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700561 int err = native_window_get_consumer_usage(surface->window.get(),
562 &surface->consumer_usage);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800563 if (err != android::OK) {
Yiwei Zhang6435b322018-05-08 11:12:17 -0700564 ALOGE("native_window_get_consumer_usage() failed: %s (%d)",
565 strerror(-err), err);
566 surface->~Surface();
567 allocator->pfnFree(allocator->pUserData, surface);
Yiwei Zhang70a21962019-05-31 17:26:52 -0700568 return VK_ERROR_SURFACE_LOST_KHR;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700569 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700570
Yiwei Zhang6435b322018-05-08 11:12:17 -0700571 err =
Jesse Hall1356b0d2015-11-23 17:24:58 -0800572 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Yiwei Zhangf5030b42019-12-19 00:10:04 -0800573 if (err != android::OK) {
Jesse Hall1356b0d2015-11-23 17:24:58 -0800574 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
575 err);
576 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800577 allocator->pfnFree(allocator->pUserData, surface);
Mike Stroyan762c8132017-02-22 11:43:09 -0700578 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800579 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700580
Jesse Hall1356b0d2015-11-23 17:24:58 -0800581 *out_surface = HandleFromSurface(surface);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700582 return VK_SUCCESS;
583}
584
Jesse Halle1b12782015-11-30 11:27:32 -0800585VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800586void DestroySurfaceKHR(VkInstance instance,
587 VkSurfaceKHR surface_handle,
588 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800589 ATRACE_CALL();
590
Jesse Hall1356b0d2015-11-23 17:24:58 -0800591 Surface* surface = SurfaceFromHandle(surface_handle);
592 if (!surface)
593 return;
594 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700595 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
Jesse Halldc225072016-05-30 22:40:14 -0700596 "destroyed VkSurfaceKHR 0x%" PRIx64
597 " has active VkSwapchainKHR 0x%" PRIx64,
598 reinterpret_cast<uint64_t>(surface_handle),
599 reinterpret_cast<uint64_t>(surface->swapchain_handle));
Jesse Hall1356b0d2015-11-23 17:24:58 -0800600 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800601 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800602 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800603 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800604}
605
Jesse Halle1b12782015-11-30 11:27:32 -0800606VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800607VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
608 uint32_t /*queue_family*/,
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000609 VkSurfaceKHR /*surface_handle*/,
Chia-I Wu62262232016-03-26 07:06:44 +0800610 VkBool32* supported) {
Yiwei Zhangc7e46c42021-02-04 22:53:59 +0000611 *supported = VK_TRUE;
Jesse Halla6429252015-11-29 18:59:42 -0800612 return VK_SUCCESS;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800613}
614
Jesse Halle1b12782015-11-30 11:27:32 -0800615VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800616VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700617 VkPhysicalDevice pdev,
Jesse Hallb00daad2015-11-29 19:46:20 -0800618 VkSurfaceKHR surface,
619 VkSurfaceCapabilitiesKHR* capabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800620 ATRACE_CALL();
621
Jesse Halld7b994a2015-09-07 14:17:37 -0700622 int err;
Jesse Halld7b994a2015-09-07 14:17:37 -0700623 int width, height;
Jesse Hall55bc0972016-02-23 16:43:29 -0800624 int transform_hint;
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800625 int max_buffer_count;
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700626 if (surface == VK_NULL_HANDLE) {
627 const InstanceData& instance_data = GetData(pdev);
628 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
629 bool surfaceless_enabled =
630 instance_data.hook_extensions.test(surfaceless);
631 if (!surfaceless_enabled) {
632 // It is an error to pass a surface==VK_NULL_HANDLE unless the
633 // VK_GOOGLE_surfaceless_query extension is enabled
634 return VK_ERROR_SURFACE_LOST_KHR;
635 }
636 // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
637 // extension for this function is for
638 // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following
639 // four values cannot be known without a surface. Default values will
640 // be supplied anyway, but cannot be relied upon.
641 width = 1000;
642 height = 1000;
643 transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
644 max_buffer_count = 10;
645 } else {
646 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
647
648 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
649 if (err != android::OK) {
650 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
651 strerror(-err), err);
652 return VK_ERROR_SURFACE_LOST_KHR;
653 }
654 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
655 if (err != android::OK) {
656 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
657 strerror(-err), err);
658 return VK_ERROR_SURFACE_LOST_KHR;
659 }
660
661 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
662 &transform_hint);
663 if (err != android::OK) {
664 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
665 strerror(-err), err);
666 return VK_ERROR_SURFACE_LOST_KHR;
667 }
668
669 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT,
670 &max_buffer_count);
671 if (err != android::OK) {
672 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
673 strerror(-err), err);
674 return VK_ERROR_SURFACE_LOST_KHR;
675 }
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800676 }
Ian Elliottf5737982021-12-01 12:35:57 -0700677 capabilities->minImageCount = std::min(max_buffer_count, 3);
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800678 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
Jesse Halld7b994a2015-09-07 14:17:37 -0700679
Jesse Hallfe2662d2016-02-09 13:26:59 -0800680 capabilities->currentExtent =
681 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
682
Yiwei Zhang70a21962019-05-31 17:26:52 -0700683 // TODO(http://b/134182502): Figure out what the max extent should be.
Jesse Hallb00daad2015-11-29 19:46:20 -0800684 capabilities->minImageExtent = VkExtent2D{1, 1};
685 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
Jesse Halld7b994a2015-09-07 14:17:37 -0700686
Jesse Hallfe2662d2016-02-09 13:26:59 -0800687 capabilities->maxImageArrayLayers = 1;
688
Jesse Hall55bc0972016-02-23 16:43:29 -0800689 capabilities->supportedTransforms = kSupportedTransforms;
690 capabilities->currentTransform =
691 TranslateNativeToVulkanTransform(transform_hint);
Jesse Halld7b994a2015-09-07 14:17:37 -0700692
Jesse Hallfe2662d2016-02-09 13:26:59 -0800693 // On Android, window composition is a WindowManager property, not something
694 // associated with the bufferqueue. It can't be changed from here.
695 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700696
Jesse Hallb00daad2015-11-29 19:46:20 -0800697 capabilities->supportedUsageFlags =
Jesse Hall3fbc8562015-11-29 22:10:52 -0800698 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
699 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
700 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
Jesse Halld7b994a2015-09-07 14:17:37 -0700701 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
702
Jesse Hallb1352bc2015-09-04 16:12:33 -0700703 return VK_SUCCESS;
704}
705
Jesse Halle1b12782015-11-30 11:27:32 -0800706VKAPI_ATTR
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700707VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
708 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800709 uint32_t* count,
710 VkSurfaceFormatKHR* formats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800711 ATRACE_CALL();
712
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700713 const InstanceData& instance_data = GetData(pdev);
714
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700715 bool wide_color_support = false;
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700716 uint64_t consumer_usage = 0;
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000717 bool colorspace_ext =
Shreshta Manu6acd8e82022-03-05 00:58:43 +0000718 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700719 if (surface_handle == VK_NULL_HANDLE) {
720 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
721 bool surfaceless_enabled =
722 instance_data.hook_extensions.test(surfaceless);
723 if (!surfaceless_enabled) {
724 return VK_ERROR_SURFACE_LOST_KHR;
725 }
726 // Support for VK_GOOGLE_surfaceless_query. The EGL loader
727 // unconditionally supports wide color formats, even if they will cause
728 // a SurfaceFlinger fallback. Based on that, wide_color_support will be
729 // set to true in this case.
730 wide_color_support = true;
731
732 // TODO(b/203826952): research proper value; temporarily use the
733 // values seen on Pixel
734 consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY;
735 } else {
736 Surface& surface = *SurfaceFromHandle(surface_handle);
737 int err = native_window_get_wide_color_support(surface.window.get(),
738 &wide_color_support);
739 if (err) {
740 return VK_ERROR_SURFACE_LOST_KHR;
741 }
742 ALOGV("wide_color_support is: %d", wide_color_support);
743
744 consumer_usage = surface.consumer_usage;
745 }
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000746 wide_color_support = wide_color_support && colorspace_ext;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700747
Charlie Lao324191f2019-12-13 11:03:16 -0800748 AHardwareBuffer_Desc desc = {};
749 desc.width = 1;
750 desc.height = 1;
751 desc.layers = 1;
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700752 desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
Charlie Lao324191f2019-12-13 11:03:16 -0800753 AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
754
755 // We must support R8G8B8A8
756 std::vector<VkSurfaceFormatKHR> all_formats = {
757 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Lingfeng Yange29191c2022-07-01 18:18:29 -0700758 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
759 // Also allow to use PASS_THROUGH + HAL_DATASPACE_ARBITRARY
760 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_PASS_THROUGH_EXT},
761 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_PASS_THROUGH_EXT},
762 };
Charlie Lao324191f2019-12-13 11:03:16 -0800763
Trevor David Black5e13d0c2022-03-10 21:18:35 +0000764 if (colorspace_ext) {
765 all_formats.emplace_back(VkSurfaceFormatKHR{
766 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT});
767 }
768
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700769 if (wide_color_support) {
Charlie Lao324191f2019-12-13 11:03:16 -0800770 all_formats.emplace_back(VkSurfaceFormatKHR{
771 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
772 all_formats.emplace_back(VkSurfaceFormatKHR{
773 VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
774 }
775
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700776 // NOTE: Any new formats that are added must be coordinated across different
777 // Android users. This includes the ANGLE team (a layered implementation of
778 // OpenGL-ES).
779
Charlie Lao324191f2019-12-13 11:03:16 -0800780 desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
781 if (AHardwareBuffer_isSupported(&desc)) {
782 all_formats.emplace_back(VkSurfaceFormatKHR{
783 VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnak52ac1e92022-07-18 13:33:10 -0700784 all_formats.emplace_back(VkSurfaceFormatKHR{
785 VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_PASS_THROUGH_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800786 }
787
788 desc.format = AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
789 if (AHardwareBuffer_isSupported(&desc)) {
790 all_formats.emplace_back(VkSurfaceFormatKHR{
791 VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnak52ac1e92022-07-18 13:33:10 -0700792 all_formats.emplace_back(VkSurfaceFormatKHR{
793 VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_PASS_THROUGH_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800794 if (wide_color_support) {
795 all_formats.emplace_back(
796 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
797 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT});
798 all_formats.emplace_back(
799 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
800 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT});
801 }
802 }
803
804 desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
805 if (AHardwareBuffer_isSupported(&desc)) {
806 all_formats.emplace_back(
807 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
808 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
Jason Macnak52ac1e92022-07-18 13:33:10 -0700809 all_formats.emplace_back(
810 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
811 VK_COLOR_SPACE_PASS_THROUGH_EXT});
Charlie Lao324191f2019-12-13 11:03:16 -0800812 if (wide_color_support) {
813 all_formats.emplace_back(
814 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
815 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
816 }
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700817 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700818
819 VkResult result = VK_SUCCESS;
820 if (formats) {
Charlie Lao324191f2019-12-13 11:03:16 -0800821 uint32_t transfer_count = all_formats.size();
822 if (transfer_count > *count) {
823 transfer_count = *count;
Jesse Halld7b994a2015-09-07 14:17:37 -0700824 result = VK_INCOMPLETE;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700825 }
Charlie Lao324191f2019-12-13 11:03:16 -0800826 std::copy(all_formats.begin(), all_formats.begin() + transfer_count,
827 formats);
828 *count = transfer_count;
Jesse Hall7331e222016-09-15 21:26:01 -0700829 } else {
Charlie Lao324191f2019-12-13 11:03:16 -0800830 *count = all_formats.size();
Jesse Halld7b994a2015-09-07 14:17:37 -0700831 }
Charlie Lao324191f2019-12-13 11:03:16 -0800832
Jesse Halld7b994a2015-09-07 14:17:37 -0700833 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700834}
835
Jesse Halle1b12782015-11-30 11:27:32 -0800836VKAPI_ATTR
Chris Forbes2452cf72017-03-16 16:30:17 +1300837VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
838 VkPhysicalDevice physicalDevice,
839 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
840 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800841 ATRACE_CALL();
842
Chris Forbes2452cf72017-03-16 16:30:17 +1300843 VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
844 physicalDevice, pSurfaceInfo->surface,
845 &pSurfaceCapabilities->surfaceCapabilities);
846
Chris Forbes06bc0092017-03-16 16:46:05 +1300847 VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
848 while (caps->pNext) {
849 caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
850
851 switch (caps->sType) {
852 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
853 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
854 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
855 caps);
856 // Claim same set of usage flags are supported for
857 // shared present modes as for other modes.
858 shared_caps->sharedPresentSupportedUsageFlags =
859 pSurfaceCapabilities->surfaceCapabilities
860 .supportedUsageFlags;
861 } break;
862
Ian Elliottd2a57282022-02-28 16:47:43 -0700863 case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
864 VkSurfaceProtectedCapabilitiesKHR* protected_caps =
865 reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(caps);
866 protected_caps->supportsProtected = VK_TRUE;
867 } break;
868
Chris Forbes06bc0092017-03-16 16:46:05 +1300869 default:
870 // Ignore all other extension structs
871 break;
872 }
873 }
874
Chris Forbes2452cf72017-03-16 16:30:17 +1300875 return result;
876}
877
878VKAPI_ATTR
879VkResult GetPhysicalDeviceSurfaceFormats2KHR(
880 VkPhysicalDevice physicalDevice,
881 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
882 uint32_t* pSurfaceFormatCount,
883 VkSurfaceFormat2KHR* pSurfaceFormats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800884 ATRACE_CALL();
885
Chris Forbes2452cf72017-03-16 16:30:17 +1300886 if (!pSurfaceFormats) {
887 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
888 pSurfaceInfo->surface,
889 pSurfaceFormatCount, nullptr);
890 } else {
891 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
892 // after the call.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700893 std::vector<VkSurfaceFormatKHR> surface_formats(*pSurfaceFormatCount);
Chris Forbes2452cf72017-03-16 16:30:17 +1300894 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
895 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
Yiwei Zhang5e862202019-06-21 14:59:16 -0700896 surface_formats.data());
Chris Forbes2452cf72017-03-16 16:30:17 +1300897
898 if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
899 // marshal results individually due to stride difference.
900 // completely ignore any chained extension structs.
901 uint32_t formats_to_marshal = *pSurfaceFormatCount;
902 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
903 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
904 }
905 }
906
907 return result;
908 }
909}
910
911VKAPI_ATTR
Chris Forbese8d79a62017-02-22 12:49:18 +1300912VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800913 VkSurfaceKHR surface,
Chia-I Wu62262232016-03-26 07:06:44 +0800914 uint32_t* count,
915 VkPresentModeKHR* modes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800916 ATRACE_CALL();
917
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800918 int err;
919 int query_value;
Shreshta Manu6acd8e82022-03-05 00:58:43 +0000920 std::vector<VkPresentModeKHR> present_modes;
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700921 if (surface == VK_NULL_HANDLE) {
922 const InstanceData& instance_data = GetData(pdev);
923 ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
924 bool surfaceless_enabled =
925 instance_data.hook_extensions.test(surfaceless);
926 if (!surfaceless_enabled) {
927 return VK_ERROR_SURFACE_LOST_KHR;
928 }
929 // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
930 // extension for this function is for
931 // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and
932 // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot
933 // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a
Ian Elliott7e361142022-06-02 10:45:17 -0600934 // surface, and that cannot be relied upon. Therefore, don't return it.
Ian Elliott8c7e6db2022-02-18 16:44:58 -0700935 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
936 } else {
937 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
938
939 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
940 &query_value);
941 if (err != android::OK || query_value < 0) {
942 ALOGE(
943 "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) "
944 "value=%d",
945 strerror(-err), err, query_value);
946 return VK_ERROR_SURFACE_LOST_KHR;
947 }
948 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
949
950 err =
951 window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
952 if (err != android::OK || query_value < 0) {
953 ALOGE(
954 "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
955 strerror(-err), err, query_value);
956 return VK_ERROR_SURFACE_LOST_KHR;
957 }
958 uint32_t max_buffer_count = static_cast<uint32_t>(query_value);
959
960 if (min_undequeued_buffers + 1 < max_buffer_count)
961 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
962 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
963 }
Chris Forbese8d79a62017-02-22 12:49:18 +1300964
965 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
Yiwei Zhang93b521c2020-07-11 16:32:09 -0700966 QueryPresentationProperties(pdev, &present_properties);
967 if (present_properties.sharedImage) {
968 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
969 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
Chris Forbese8d79a62017-02-22 12:49:18 +1300970 }
971
972 uint32_t num_modes = uint32_t(present_modes.size());
Jesse Halld7b994a2015-09-07 14:17:37 -0700973
974 VkResult result = VK_SUCCESS;
975 if (modes) {
Chris Forbese8d79a62017-02-22 12:49:18 +1300976 if (*count < num_modes)
Jesse Halld7b994a2015-09-07 14:17:37 -0700977 result = VK_INCOMPLETE;
Chris Forbese8d79a62017-02-22 12:49:18 +1300978 *count = std::min(*count, num_modes);
Yiwei Zhang5e862202019-06-21 14:59:16 -0700979 std::copy_n(present_modes.data(), *count, modes);
Jesse Hall7331e222016-09-15 21:26:01 -0700980 } else {
Chris Forbese8d79a62017-02-22 12:49:18 +1300981 *count = num_modes;
Jesse Halld7b994a2015-09-07 14:17:37 -0700982 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700983 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700984}
985
Jesse Halle1b12782015-11-30 11:27:32 -0800986VKAPI_ATTR
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400987VkResult GetDeviceGroupPresentCapabilitiesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -0600988 VkDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400989 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800990 ATRACE_CALL();
991
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400992 ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
993 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
994 "vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
995 "VkDeviceGroupPresentCapabilitiesKHR structure type %d",
996 pDeviceGroupPresentCapabilities->sType);
997
998 memset(pDeviceGroupPresentCapabilities->presentMask, 0,
999 sizeof(pDeviceGroupPresentCapabilities->presentMask));
1000
1001 // assume device group of size 1
1002 pDeviceGroupPresentCapabilities->presentMask[0] = 1 << 0;
1003 pDeviceGroupPresentCapabilities->modes =
1004 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
1005
1006 return VK_SUCCESS;
1007}
1008
1009VKAPI_ATTR
1010VkResult GetDeviceGroupSurfacePresentModesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -06001011 VkDevice,
1012 VkSurfaceKHR,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001013 VkDeviceGroupPresentModeFlagsKHR* pModes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001014 ATRACE_CALL();
1015
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001016 *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
1017 return VK_SUCCESS;
1018}
1019
1020VKAPI_ATTR
Ian Elliottcd8ad332017-10-13 09:21:12 -06001021VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001022 VkSurfaceKHR surface,
1023 uint32_t* pRectCount,
1024 VkRect2D* pRects) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001025 ATRACE_CALL();
1026
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001027 if (!pRects) {
1028 *pRectCount = 1;
1029 } else {
1030 uint32_t count = std::min(*pRectCount, 1u);
1031 bool incomplete = *pRectCount < 1;
1032
1033 *pRectCount = count;
1034
1035 if (incomplete) {
1036 return VK_INCOMPLETE;
1037 }
1038
1039 int err;
1040 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
1041
1042 int width = 0, height = 0;
1043 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001044 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001045 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
1046 strerror(-err), err);
1047 }
1048 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001049 if (err != android::OK) {
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001050 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
1051 strerror(-err), err);
1052 }
1053
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001054 pRects[0].offset.x = 0;
1055 pRects[0].offset.y = 0;
1056 pRects[0].extent = VkExtent2D{static_cast<uint32_t>(width),
1057 static_cast<uint32_t>(height)};
1058 }
1059 return VK_SUCCESS;
1060}
1061
Yiwei Zhang533cea92019-06-03 18:43:24 -07001062static void DestroySwapchainInternal(VkDevice device,
1063 VkSwapchainKHR swapchain_handle,
1064 const VkAllocationCallbacks* allocator) {
1065 ATRACE_CALL();
1066
1067 const auto& dispatch = GetData(device).driver;
1068 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
1069 if (!swapchain) {
1070 return;
1071 }
1072
1073 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1074 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1075
1076 if (window && swapchain->frame_timestamps_enabled) {
1077 native_window_enable_frame_timestamps(window, false);
1078 }
1079
1080 for (uint32_t i = 0; i < swapchain->num_images; i++) {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001081 ReleaseSwapchainImage(device, window, -1, swapchain->images[i], false);
Yiwei Zhang533cea92019-06-03 18:43:24 -07001082 }
1083
1084 if (active) {
1085 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1086 }
1087
1088 if (!allocator) {
1089 allocator = &GetData(device).allocator;
1090 }
1091
1092 swapchain->~Swapchain();
1093 allocator->pfnFree(allocator->pUserData, swapchain);
1094}
1095
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001096VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001097VkResult CreateSwapchainKHR(VkDevice device,
1098 const VkSwapchainCreateInfoKHR* create_info,
1099 const VkAllocationCallbacks* allocator,
1100 VkSwapchainKHR* swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001101 ATRACE_CALL();
1102
Jesse Halld7b994a2015-09-07 14:17:37 -07001103 int err;
1104 VkResult result = VK_SUCCESS;
1105
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001106 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
1107 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
1108 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
1109 " oldSwapchain=0x%" PRIx64,
1110 reinterpret_cast<uint64_t>(create_info->surface),
1111 create_info->minImageCount, create_info->imageFormat,
1112 create_info->imageColorSpace, create_info->imageExtent.width,
1113 create_info->imageExtent.height, create_info->imageUsage,
1114 create_info->preTransform, create_info->presentMode,
1115 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1116
Jesse Hall1f91d392015-12-11 16:28:44 -08001117 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001118 allocator = &GetData(device).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -08001119
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001120 android_pixel_format native_pixel_format =
1121 GetNativePixelFormat(create_info->imageFormat);
1122 android_dataspace native_dataspace =
1123 GetNativeDataspace(create_info->imageColorSpace);
1124 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
1125 ALOGE(
1126 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
1127 "failed: Unsupported color space",
1128 create_info->imageColorSpace);
1129 return VK_ERROR_INITIALIZATION_FAILED;
1130 }
1131
Jesse Hall42a9eec2016-06-03 12:39:49 -07001132 ALOGV_IF(create_info->imageArrayLayers != 1,
Jesse Halldc225072016-05-30 22:40:14 -07001133 "swapchain imageArrayLayers=%u not supported",
Jesse Hall715b86a2016-01-16 16:34:29 -08001134 create_info->imageArrayLayers);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001135 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
Jesse Halldc225072016-05-30 22:40:14 -07001136 "swapchain preTransform=%#x not supported",
Jesse Hall55bc0972016-02-23 16:43:29 -08001137 create_info->preTransform);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001138 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
Chris Forbes980ad052017-01-18 16:55:07 +13001139 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
Chris Forbes1d5f68c2017-01-31 10:17:01 +13001140 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1141 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
Jesse Halldc225072016-05-30 22:40:14 -07001142 "swapchain presentMode=%u not supported",
Jesse Hall0ae0dce2016-02-09 22:13:34 -08001143 create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -07001144
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001145 Surface& surface = *SurfaceFromHandle(create_info->surface);
1146
Jesse Halldc225072016-05-30 22:40:14 -07001147 if (surface.swapchain_handle != create_info->oldSwapchain) {
Jesse Hall42a9eec2016-06-03 12:39:49 -07001148 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
Jesse Halldc225072016-05-30 22:40:14 -07001149 " because it already has active swapchain 0x%" PRIx64
1150 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
1151 reinterpret_cast<uint64_t>(create_info->surface),
1152 reinterpret_cast<uint64_t>(surface.swapchain_handle),
1153 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1154 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
1155 }
1156 if (create_info->oldSwapchain != VK_NULL_HANDLE)
1157 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
1158
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001159 // -- Reset the native window --
1160 // The native window might have been used previously, and had its properties
1161 // changed from defaults. That will affect the answer we get for queries
1162 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
1163 // attempt such queries.
1164
Jesse Halldc225072016-05-30 22:40:14 -07001165 // The native window only allows dequeueing all buffers before any have
1166 // been queued, since after that point at least one is assumed to be in
1167 // non-FREE state at any given time. Disconnecting and re-connecting
1168 // orphans the previous buffers, getting us back to the state where we can
1169 // dequeue all buffers.
Yiwei Zhang70a21962019-05-31 17:26:52 -07001170 //
1171 // TODO(http://b/134186185) recycle swapchain images more efficiently
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001172 ANativeWindow* window = surface.window.get();
1173 err = native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
1174 ALOGW_IF(err != android::OK, "native_window_api_disconnect failed: %s (%d)",
Jesse Halldc225072016-05-30 22:40:14 -07001175 strerror(-err), err);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001176 err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
1177 ALOGW_IF(err != android::OK, "native_window_api_connect failed: %s (%d)",
Jesse Halldc225072016-05-30 22:40:14 -07001178 strerror(-err), err);
1179
Nicolas Capens147b7da2021-04-09 14:53:06 -04001180 err =
1181 window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, nsecs_t{-1});
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001182 if (err != android::OK) {
1183 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1184 strerror(-err), err);
1185 return VK_ERROR_SURFACE_LOST_KHR;
1186 }
1187
Hrishikesh Manohar9b7e4532017-01-10 17:52:11 +05301188 int swap_interval =
1189 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001190 err = window->setSwapInterval(window, swap_interval);
1191 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001192 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
1193 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001194 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001195 }
1196
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001197 err = native_window_set_shared_buffer_mode(window, false);
1198 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001199 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
1200 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001201 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001202 }
1203
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001204 err = native_window_set_auto_refresh(window, false);
1205 if (err != android::OK) {
Chris Forbesb8042d22017-01-18 18:07:05 +13001206 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
1207 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001208 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001209 }
1210
Jesse Halld7b994a2015-09-07 14:17:37 -07001211 // -- Configure the native window --
Jesse Halld7b994a2015-09-07 14:17:37 -07001212
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001213 const auto& dispatch = GetData(device).driver;
Jesse Hall70f93352015-11-04 09:41:31 -08001214
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001215 err = native_window_set_buffers_format(window, native_pixel_format);
1216 if (err != android::OK) {
Jesse Hall517274a2016-02-10 00:07:18 -08001217 ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001218 native_pixel_format, strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001219 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001220 }
Yiwei Zhang51572c22022-07-22 23:08:30 +00001221
1222 /* Respect consumer default dataspace upon HAL_DATASPACE_ARBITRARY. */
1223 if (native_dataspace != HAL_DATASPACE_ARBITRARY) {
1224 err = native_window_set_buffers_data_space(window, native_dataspace);
1225 if (err != android::OK) {
1226 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
1227 native_dataspace, strerror(-err), err);
1228 return VK_ERROR_SURFACE_LOST_KHR;
1229 }
Jesse Hall517274a2016-02-10 00:07:18 -08001230 }
1231
Jesse Hall3dd678a2016-01-08 21:52:01 -08001232 err = native_window_set_buffers_dimensions(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001233 window, static_cast<int>(create_info->imageExtent.width),
Jesse Hall3dd678a2016-01-08 21:52:01 -08001234 static_cast<int>(create_info->imageExtent.height));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001235 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001236 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
1237 create_info->imageExtent.width, create_info->imageExtent.height,
1238 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001239 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001240 }
1241
Jesse Hall178b6962016-02-24 15:39:50 -08001242 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
1243 // applied during rendering. native_window_set_transform() expects the
1244 // inverse: the transform the app is requesting that the compositor perform
1245 // during composition. With native windows, pre-transform works by rendering
1246 // with the same transform the compositor is applying (as in Vulkan), but
1247 // then requesting the inverse transform, so that when the compositor does
1248 // it's job the two transforms cancel each other out and the compositor ends
1249 // up applying an identity transform to the app's buffer.
1250 err = native_window_set_buffers_transform(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001251 window, InvertTransformToNative(create_info->preTransform));
1252 if (err != android::OK) {
Jesse Hall178b6962016-02-24 15:39:50 -08001253 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
1254 InvertTransformToNative(create_info->preTransform),
1255 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001256 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall178b6962016-02-24 15:39:50 -08001257 }
1258
Jesse Hallf64ca122015-11-03 16:11:10 -08001259 err = native_window_set_scaling_mode(
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001260 window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
1261 if (err != android::OK) {
Jesse Hallf64ca122015-11-03 16:11:10 -08001262 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
1263 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001264 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hallf64ca122015-11-03 16:11:10 -08001265 }
1266
Chris Forbes97ef4612017-03-30 19:37:50 +13001267 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
1268 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1269 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1270 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001271 err = native_window_set_shared_buffer_mode(window, true);
1272 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001273 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
1274 return VK_ERROR_SURFACE_LOST_KHR;
1275 }
1276 }
1277
1278 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001279 err = native_window_set_auto_refresh(window, true);
1280 if (err != android::OK) {
Chris Forbes97ef4612017-03-30 19:37:50 +13001281 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
1282 return VK_ERROR_SURFACE_LOST_KHR;
1283 }
1284 }
1285
Ian Elliottf5737982021-12-01 12:35:57 -07001286 int query_value;
1287 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
1288 &query_value);
1289 if (err != android::OK || query_value < 0) {
1290 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
1291 query_value);
Mike Stroyan762c8132017-02-22 11:43:09 -07001292 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001293 }
Ian Elliottf5737982021-12-01 12:35:57 -07001294 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
1295 const auto mailbox_num_images = std::max(3u, create_info->minImageCount);
1296 const auto requested_images =
1297 swap_interval ? create_info->minImageCount : mailbox_num_images;
1298 uint32_t num_images = requested_images - 1 + min_undequeued_buffers;
Chris Forbes2c8fc752017-03-17 11:28:32 +13001299
Ian Elliott5396b702021-12-13 19:32:34 -07001300 // Lower layer insists that we have at least min_undequeued_buffers + 1
1301 // buffers. This is wasteful and we'd like to relax it in the shared case,
1302 // but not all the pieces are in place for that to work yet. Note we only
1303 // lie to the lower layer--we don't want to give the app back a swapchain
1304 // with extra images (which they can't actually use!).
1305 uint32_t min_buffer_count = min_undequeued_buffers + 1;
1306 err = native_window_set_buffer_count(
1307 window, std::max(min_buffer_count, num_images));
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001308 if (err != android::OK) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001309 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
1310 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001311 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001312 }
1313
Ian Elliott5396b702021-12-13 19:32:34 -07001314 // In shared mode the num_images must be one regardless of how many
1315 // buffers were allocated for the buffer queue.
1316 if (swapchain_image_usage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) {
1317 num_images = 1;
1318 }
1319
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001320 int32_t legacy_usage = 0;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001321 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
Jesse Halld1abd742017-02-09 21:45:51 -08001322 uint64_t consumer_usage, producer_usage;
Yiwei Zhang533cea92019-06-03 18:43:24 -07001323 ATRACE_BEGIN("GetSwapchainGrallocUsage2ANDROID");
Courtney Goeltzenleuchter894780b2017-04-03 16:11:30 -06001324 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1325 device, create_info->imageFormat, create_info->imageUsage,
1326 swapchain_image_usage, &consumer_usage, &producer_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001327 ATRACE_END();
Chris Forbes8c47dc92017-01-12 11:13:58 +13001328 if (result != VK_SUCCESS) {
1329 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001330 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001331 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001332 legacy_usage =
Jesse Hall79927812017-03-23 11:03:23 -07001333 android_convertGralloc1To0Usage(producer_usage, consumer_usage);
Chris Forbes8c47dc92017-01-12 11:13:58 +13001334 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001335 ATRACE_BEGIN("GetSwapchainGrallocUsageANDROID");
Jesse Hall1f91d392015-12-11 16:28:44 -08001336 result = dispatch.GetSwapchainGrallocUsageANDROID(
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001337 device, create_info->imageFormat, create_info->imageUsage,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001338 &legacy_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001339 ATRACE_END();
Jesse Hall70f93352015-11-04 09:41:31 -08001340 if (result != VK_SUCCESS) {
1341 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001342 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001343 }
Jesse Hall70f93352015-11-04 09:41:31 -08001344 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001345 uint64_t native_usage = static_cast<uint64_t>(legacy_usage);
1346
1347 bool createProtectedSwapchain = false;
1348 if (create_info->flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
1349 createProtectedSwapchain = true;
1350 native_usage |= BufferUsage::PROTECTED;
1351 }
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001352 err = native_window_set_usage(window, native_usage);
1353 if (err != android::OK) {
Jesse Hall70f93352015-11-04 09:41:31 -08001354 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001355 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001356 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001357
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001358 int transform_hint;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001359 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
1360 if (err != android::OK) {
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001361 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1362 strerror(-err), err);
1363 return VK_ERROR_SURFACE_LOST_KHR;
1364 }
1365
Jesse Halld7b994a2015-09-07 14:17:37 -07001366 // -- Allocate our Swapchain object --
1367 // After this point, we must deallocate the swapchain on error.
1368
Jesse Hall1f91d392015-12-11 16:28:44 -08001369 void* mem = allocator->pfnAllocation(allocator->pUserData,
1370 sizeof(Swapchain), alignof(Swapchain),
1371 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001372 if (!mem)
Jesse Halld7b994a2015-09-07 14:17:37 -07001373 return VK_ERROR_OUT_OF_HOST_MEMORY;
silence_dogood73597592019-05-23 16:57:37 -07001374 Swapchain* swapchain = new (mem)
1375 Swapchain(surface, num_images, create_info->presentMode,
1376 TranslateVulkanToNativeTransform(create_info->preTransform));
Jesse Halld7b994a2015-09-07 14:17:37 -07001377 // -- Dequeue all buffers and create a VkImage for each --
1378 // Any failures during or after this must cancel the dequeued buffers.
1379
Chris Forbesb56287a2017-01-12 14:28:58 +13001380 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1381#pragma clang diagnostic push
1382#pragma clang diagnostic ignored "-Wold-style-cast"
1383 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1384#pragma clang diagnostic pop
1385 .pNext = nullptr,
1386 .usage = swapchain_image_usage,
1387 };
Jesse Halld7b994a2015-09-07 14:17:37 -07001388 VkNativeBufferANDROID image_native_buffer = {
Jesse Halld7b994a2015-09-07 14:17:37 -07001389#pragma clang diagnostic push
1390#pragma clang diagnostic ignored "-Wold-style-cast"
1391 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1392#pragma clang diagnostic pop
Chris Forbesb56287a2017-01-12 14:28:58 +13001393 .pNext = &swapchain_image_create,
Jesse Halld7b994a2015-09-07 14:17:37 -07001394 };
1395 VkImageCreateInfo image_create = {
1396 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1397 .pNext = &image_native_buffer,
Nick Desaulnierse745a3e2019-10-18 10:38:45 -07001398 .flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
Jesse Halld7b994a2015-09-07 14:17:37 -07001399 .imageType = VK_IMAGE_TYPE_2D,
Jesse Hall517274a2016-02-10 00:07:18 -08001400 .format = create_info->imageFormat,
Jesse Halld7b994a2015-09-07 14:17:37 -07001401 .extent = {0, 0, 1},
1402 .mipLevels = 1,
Jesse Halla15a4bf2015-11-19 22:48:02 -08001403 .arrayLayers = 1,
Jesse Hall091ed9e2015-11-30 00:55:29 -08001404 .samples = VK_SAMPLE_COUNT_1_BIT,
Jesse Halld7b994a2015-09-07 14:17:37 -07001405 .tiling = VK_IMAGE_TILING_OPTIMAL,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001406 .usage = create_info->imageUsage,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001407 .sharingMode = create_info->imageSharingMode,
Jesse Hall03b6fe12015-11-24 12:44:21 -08001408 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
Jesse Halld7b994a2015-09-07 14:17:37 -07001409 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1410 };
1411
Jesse Halld7b994a2015-09-07 14:17:37 -07001412 for (uint32_t i = 0; i < num_images; i++) {
1413 Swapchain::Image& img = swapchain->images[i];
1414
1415 ANativeWindowBuffer* buffer;
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001416 err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
1417 if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001418 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
Yiwei Zhang702beb42019-11-29 17:59:55 -08001419 switch (-err) {
1420 case ENOMEM:
1421 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
1422 break;
1423 default:
1424 result = VK_ERROR_SURFACE_LOST_KHR;
1425 break;
1426 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001427 break;
1428 }
Chia-I Wue8e689f2016-04-18 08:21:31 +08001429 img.buffer = buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -07001430 img.dequeued = true;
1431
1432 image_create.extent =
Jesse Hall3dd678a2016-01-08 21:52:01 -08001433 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1434 static_cast<uint32_t>(img.buffer->height),
1435 1};
Jesse Halld7b994a2015-09-07 14:17:37 -07001436 image_native_buffer.handle = img.buffer->handle;
1437 image_native_buffer.stride = img.buffer->stride;
1438 image_native_buffer.format = img.buffer->format;
Mathias Agopiancb496ac2017-05-22 14:21:00 -07001439 image_native_buffer.usage = int(img.buffer->usage);
Chris Forbes8e0c3f52017-05-19 14:47:29 -07001440 android_convertGralloc0To1Usage(int(img.buffer->usage),
1441 &image_native_buffer.usage2.producer,
1442 &image_native_buffer.usage2.consumer);
Jesse Halld7b994a2015-09-07 14:17:37 -07001443
Yiwei Zhang533cea92019-06-03 18:43:24 -07001444 ATRACE_BEGIN("CreateImage");
Jesse Hall03b6fe12015-11-24 12:44:21 -08001445 result =
Jesse Hall1f91d392015-12-11 16:28:44 -08001446 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001447 ATRACE_END();
Jesse Halld7b994a2015-09-07 14:17:37 -07001448 if (result != VK_SUCCESS) {
1449 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1450 break;
1451 }
1452 }
1453
1454 // -- Cancel all buffers, returning them to the queue --
1455 // If an error occurred before, also destroy the VkImage and release the
1456 // buffer reference. Otherwise, we retain a strong reference to the buffer.
Chris Forbes31b85c22018-05-29 15:03:28 -07001457 for (uint32_t i = 0; i < num_images; i++) {
1458 Swapchain::Image& img = swapchain->images[i];
1459 if (img.dequeued) {
1460 if (!swapchain->shared) {
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001461 window->cancelBuffer(window, img.buffer.get(),
1462 img.dequeue_fence);
Chris Forbese0ced032017-03-30 19:44:15 +13001463 img.dequeue_fence = -1;
1464 img.dequeued = false;
1465 }
Chris Forbes31b85c22018-05-29 15:03:28 -07001466 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001467 }
1468
1469 if (result != VK_SUCCESS) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001470 DestroySwapchainInternal(device, HandleFromSwapchain(swapchain),
1471 allocator);
Jesse Halld7b994a2015-09-07 14:17:37 -07001472 return result;
1473 }
1474
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001475 if (transform_hint != swapchain->pre_transform) {
1476 // Log that the app is not doing pre-rotation.
1477 android::GraphicsEnv::getInstance().setTargetStats(
1478 android::GpuStatsInfo::Stats::FALSE_PREROTATION);
1479 }
1480
Jesse Halldc225072016-05-30 22:40:14 -07001481 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1482 *swapchain_handle = surface.swapchain_handle;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001483 return VK_SUCCESS;
1484}
1485
Jesse Halle1b12782015-11-30 11:27:32 -08001486VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001487void DestroySwapchainKHR(VkDevice device,
1488 VkSwapchainKHR swapchain_handle,
1489 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001490 ATRACE_CALL();
1491
Yiwei Zhang533cea92019-06-03 18:43:24 -07001492 DestroySwapchainInternal(device, swapchain_handle, allocator);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001493}
1494
Jesse Halle1b12782015-11-30 11:27:32 -08001495VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001496VkResult GetSwapchainImagesKHR(VkDevice,
1497 VkSwapchainKHR swapchain_handle,
1498 uint32_t* count,
1499 VkImage* images) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001500 ATRACE_CALL();
1501
Jesse Halld7b994a2015-09-07 14:17:37 -07001502 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Halldc225072016-05-30 22:40:14 -07001503 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1504 "getting images for non-active swapchain 0x%" PRIx64
1505 "; only dequeued image handles are valid",
1506 reinterpret_cast<uint64_t>(swapchain_handle));
Jesse Halld7b994a2015-09-07 14:17:37 -07001507 VkResult result = VK_SUCCESS;
1508 if (images) {
1509 uint32_t n = swapchain.num_images;
1510 if (*count < swapchain.num_images) {
1511 n = *count;
1512 result = VK_INCOMPLETE;
1513 }
1514 for (uint32_t i = 0; i < n; i++)
1515 images[i] = swapchain.images[i].image;
Jesse Hall7331e222016-09-15 21:26:01 -07001516 *count = n;
1517 } else {
1518 *count = swapchain.num_images;
Jesse Halld7b994a2015-09-07 14:17:37 -07001519 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001520 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001521}
1522
Jesse Halle1b12782015-11-30 11:27:32 -08001523VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001524VkResult AcquireNextImageKHR(VkDevice device,
1525 VkSwapchainKHR swapchain_handle,
1526 uint64_t timeout,
1527 VkSemaphore semaphore,
1528 VkFence vk_fence,
1529 uint32_t* image_index) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001530 ATRACE_CALL();
1531
Jesse Halld7b994a2015-09-07 14:17:37 -07001532 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001533 ANativeWindow* window = swapchain.surface.window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -07001534 VkResult result;
1535 int err;
1536
Jesse Halldc225072016-05-30 22:40:14 -07001537 if (swapchain.surface.swapchain_handle != swapchain_handle)
1538 return VK_ERROR_OUT_OF_DATE_KHR;
1539
Chris Forbesc88409c2017-03-30 19:47:37 +13001540 if (swapchain.shared) {
1541 // In shared mode, we keep the buffer dequeued all the time, so we don't
1542 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1543 // the semaphore and fence passed to us will be signalled.
1544 *image_index = 0;
1545 result = GetData(device).driver.AcquireImageANDROID(
1546 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1547 return result;
1548 }
1549
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001550 const nsecs_t acquire_next_image_timeout =
1551 timeout > (uint64_t)std::numeric_limits<nsecs_t>::max() ? -1 : timeout;
1552 if (acquire_next_image_timeout != swapchain.acquire_next_image_timeout) {
1553 // Cache the timeout to avoid the duplicate binder cost.
1554 err = window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT,
1555 acquire_next_image_timeout);
1556 if (err != android::OK) {
1557 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1558 strerror(-err), err);
1559 return VK_ERROR_SURFACE_LOST_KHR;
1560 }
1561 swapchain.acquire_next_image_timeout = acquire_next_image_timeout;
1562 }
1563
Jesse Halld7b994a2015-09-07 14:17:37 -07001564 ANativeWindowBuffer* buffer;
Jesse Hall06193802015-12-03 16:12:51 -08001565 int fence_fd;
1566 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Yiwei Zhangc0f8a2c2020-04-30 20:23:13 -07001567 if (err == android::TIMED_OUT || err == android::INVALID_OPERATION) {
Yiwei Zhang705c2e62019-12-18 23:12:43 -08001568 ALOGW("dequeueBuffer timed out: %s (%d)", strerror(-err), err);
1569 return timeout ? VK_TIMEOUT : VK_NOT_READY;
1570 } else if (err != android::OK) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001571 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001572 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001573 }
1574
1575 uint32_t idx;
1576 for (idx = 0; idx < swapchain.num_images; idx++) {
1577 if (swapchain.images[idx].buffer.get() == buffer) {
1578 swapchain.images[idx].dequeued = true;
Jesse Hall06193802015-12-03 16:12:51 -08001579 swapchain.images[idx].dequeue_fence = fence_fd;
Jesse Halld7b994a2015-09-07 14:17:37 -07001580 break;
1581 }
1582 }
1583 if (idx == swapchain.num_images) {
1584 ALOGE("dequeueBuffer returned unrecognized buffer");
Jesse Hall06193802015-12-03 16:12:51 -08001585 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001586 return VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001587 }
1588
1589 int fence_clone = -1;
Jesse Hall06193802015-12-03 16:12:51 -08001590 if (fence_fd != -1) {
1591 fence_clone = dup(fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001592 if (fence_clone == -1) {
1593 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1594 strerror(errno), errno);
Jesse Hall06193802015-12-03 16:12:51 -08001595 sync_wait(fence_fd, -1 /* forever */);
Jesse Halld7b994a2015-09-07 14:17:37 -07001596 }
1597 }
1598
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001599 result = GetData(device).driver.AcquireImageANDROID(
Jesse Hall1f91d392015-12-11 16:28:44 -08001600 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001601 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001602 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1603 // even if the call fails. We could close it ourselves on failure, but
1604 // that would create a race condition if the driver closes it on a
1605 // failure path: some other thread might create an fd with the same
1606 // number between the time the driver closes it and the time we close
1607 // it. We must assume one of: the driver *always* closes it even on
1608 // failure, or *never* closes it on failure.
Jesse Hall06193802015-12-03 16:12:51 -08001609 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001610 swapchain.images[idx].dequeued = false;
1611 swapchain.images[idx].dequeue_fence = -1;
1612 return result;
1613 }
1614
1615 *image_index = idx;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001616 return VK_SUCCESS;
1617}
1618
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001619VKAPI_ATTR
1620VkResult AcquireNextImage2KHR(VkDevice device,
1621 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1622 uint32_t* pImageIndex) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001623 ATRACE_CALL();
1624
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001625 return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
1626 pAcquireInfo->timeout, pAcquireInfo->semaphore,
1627 pAcquireInfo->fence, pImageIndex);
1628}
1629
Jesse Halldc225072016-05-30 22:40:14 -07001630static VkResult WorstPresentResult(VkResult a, VkResult b) {
1631 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1632 // (in spec version 1.0.14).
1633 static const VkResult kWorstToBest[] = {
1634 VK_ERROR_DEVICE_LOST,
1635 VK_ERROR_SURFACE_LOST_KHR,
1636 VK_ERROR_OUT_OF_DATE_KHR,
1637 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1638 VK_ERROR_OUT_OF_HOST_MEMORY,
1639 VK_SUBOPTIMAL_KHR,
1640 };
1641 for (auto result : kWorstToBest) {
1642 if (a == result || b == result)
1643 return result;
1644 }
1645 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1646 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1647 return a != VK_SUCCESS ? a : b;
1648}
1649
Jesse Halle1b12782015-11-30 11:27:32 -08001650VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001651VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001652 ATRACE_CALL();
1653
Jesse Halld7b994a2015-09-07 14:17:37 -07001654 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1655 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1656 present_info->sType);
Jesse Halld7b994a2015-09-07 14:17:37 -07001657
Jesse Halldc225072016-05-30 22:40:14 -07001658 VkDevice device = GetData(queue).driver_device;
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001659 const auto& dispatch = GetData(queue).driver;
Jesse Halld7b994a2015-09-07 14:17:37 -07001660 VkResult final_result = VK_SUCCESS;
Jesse Halldc225072016-05-30 22:40:14 -07001661
Ian Elliottcb351132016-12-13 10:30:40 -07001662 // Look at the pNext chain for supported extension structs:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001663 const VkPresentRegionsKHR* present_regions = nullptr;
1664 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001665 const VkPresentRegionsKHR* next =
1666 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1667 while (next) {
1668 switch (next->sType) {
1669 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1670 present_regions = next;
1671 break;
Ian Elliott14866bb2017-01-20 09:15:48 -07001672 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001673 present_times =
1674 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1675 break;
Ian Elliottcb351132016-12-13 10:30:40 -07001676 default:
1677 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1678 next->sType);
1679 break;
1680 }
1681 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1682 }
1683 ALOGV_IF(
1684 present_regions &&
1685 present_regions->swapchainCount != present_info->swapchainCount,
1686 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001687 ALOGV_IF(present_times &&
1688 present_times->swapchainCount != present_info->swapchainCount,
1689 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1690 "VkPresentInfo::swapchainCount");
Ian Elliottcb351132016-12-13 10:30:40 -07001691 const VkPresentRegionKHR* regions =
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001692 (present_regions) ? present_regions->pRegions : nullptr;
1693 const VkPresentTimeGOOGLE* times =
1694 (present_times) ? present_times->pTimes : nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001695 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001696 android_native_rect_t* rects = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001697 uint32_t nrects = 0;
1698
Jesse Halld7b994a2015-09-07 14:17:37 -07001699 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1700 Swapchain& swapchain =
Jesse Hall03b6fe12015-11-24 12:44:21 -08001701 *SwapchainFromHandle(present_info->pSwapchains[sc]);
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001702 uint32_t image_idx = present_info->pImageIndices[sc];
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001703 Swapchain::Image& img = swapchain.images[image_idx];
Ian Elliottffedb652017-02-14 10:58:30 -07001704 const VkPresentRegionKHR* region =
1705 (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001706 const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
Jesse Halldc225072016-05-30 22:40:14 -07001707 VkResult swapchain_result = VK_SUCCESS;
Jesse Halld7b994a2015-09-07 14:17:37 -07001708 VkResult result;
1709 int err;
1710
Jesse Halld7b994a2015-09-07 14:17:37 -07001711 int fence = -1;
Jesse Hall275d76c2016-01-08 22:39:16 -08001712 result = dispatch.QueueSignalReleaseImageANDROID(
1713 queue, present_info->waitSemaphoreCount,
1714 present_info->pWaitSemaphores, img.image, &fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001715 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001716 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
Jesse Halldc225072016-05-30 22:40:14 -07001717 swapchain_result = result;
Jesse Halld7b994a2015-09-07 14:17:37 -07001718 }
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001719 if (img.release_fence >= 0)
1720 close(img.release_fence);
1721 img.release_fence = fence < 0 ? -1 : dup(fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001722
Jesse Halldc225072016-05-30 22:40:14 -07001723 if (swapchain.surface.swapchain_handle ==
1724 present_info->pSwapchains[sc]) {
1725 ANativeWindow* window = swapchain.surface.window.get();
1726 if (swapchain_result == VK_SUCCESS) {
Ian Elliottcb351132016-12-13 10:30:40 -07001727 if (region) {
1728 // Process the incremental-present hint for this swapchain:
1729 uint32_t rcount = region->rectangleCount;
1730 if (rcount > nrects) {
1731 android_native_rect_t* new_rects =
1732 static_cast<android_native_rect_t*>(
1733 allocator->pfnReallocation(
1734 allocator->pUserData, rects,
1735 sizeof(android_native_rect_t) * rcount,
1736 alignof(android_native_rect_t),
1737 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1738 if (new_rects) {
1739 rects = new_rects;
1740 nrects = rcount;
1741 } else {
1742 rcount = 0; // Ignore the hint for this swapchain
1743 }
1744 }
1745 for (uint32_t r = 0; r < rcount; ++r) {
1746 if (region->pRectangles[r].layer > 0) {
1747 ALOGV(
1748 "vkQueuePresentKHR ignoring invalid layer "
1749 "(%u); using layer 0 instead",
1750 region->pRectangles[r].layer);
1751 }
1752 int x = region->pRectangles[r].offset.x;
1753 int y = region->pRectangles[r].offset.y;
1754 int width = static_cast<int>(
1755 region->pRectangles[r].extent.width);
1756 int height = static_cast<int>(
1757 region->pRectangles[r].extent.height);
1758 android_native_rect_t* cur_rect = &rects[r];
1759 cur_rect->left = x;
1760 cur_rect->top = y + height;
1761 cur_rect->right = x + width;
1762 cur_rect->bottom = y;
1763 }
1764 native_window_set_surface_damage(window, rects, rcount);
1765 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001766 if (time) {
1767 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001768 ALOGV(
1769 "Calling "
1770 "native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001771 native_window_enable_frame_timestamps(window, true);
1772 swapchain.frame_timestamps_enabled = true;
1773 }
Brian Anderson1049d1d2016-12-16 17:25:57 -08001774
1775 // Record the nativeFrameId so it can be later correlated to
1776 // this present.
1777 uint64_t nativeFrameId = 0;
1778 err = native_window_get_next_frame_id(
1779 window, &nativeFrameId);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001780 if (err != android::OK) {
Brian Anderson1049d1d2016-12-16 17:25:57 -08001781 ALOGE("Failed to get next native frame ID.");
1782 }
1783
1784 // Add a new timing record with the user's presentID and
1785 // the nativeFrameId.
Yiwei Zhang5e862202019-06-21 14:59:16 -07001786 swapchain.timing.emplace_back(time, nativeFrameId);
Brian Anderson1049d1d2016-12-16 17:25:57 -08001787 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
Yiwei Zhang5e862202019-06-21 14:59:16 -07001788 swapchain.timing.erase(swapchain.timing.begin());
Ian Elliott8a977262017-01-19 09:05:58 -07001789 }
1790 if (time->desiredPresentTime) {
1791 // Set the desiredPresentTime:
1792 ALOGV(
1793 "Calling "
1794 "native_window_set_buffers_timestamp(%" PRId64 ")",
1795 time->desiredPresentTime);
1796 native_window_set_buffers_timestamp(
1797 window,
1798 static_cast<int64_t>(time->desiredPresentTime));
1799 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001800 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001801
Jesse Halldc225072016-05-30 22:40:14 -07001802 err = window->queueBuffer(window, img.buffer.get(), fence);
1803 // queueBuffer always closes fence, even on error
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001804 if (err != android::OK) {
Jesse Halldc225072016-05-30 22:40:14 -07001805 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1806 swapchain_result = WorstPresentResult(
Yiwei Zhang492dd5f2021-03-09 22:54:38 +00001807 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhang0b468472019-06-03 18:57:19 -07001808 } else {
1809 if (img.dequeue_fence >= 0) {
1810 close(img.dequeue_fence);
1811 img.dequeue_fence = -1;
1812 }
1813 img.dequeued = false;
Jesse Halldc225072016-05-30 22:40:14 -07001814 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001815
1816 // If the swapchain is in shared mode, immediately dequeue the
1817 // buffer so it can be presented again without an intervening
1818 // call to AcquireNextImageKHR. We expect to get the same buffer
1819 // back from every call to dequeueBuffer in this mode.
1820 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
1821 ANativeWindowBuffer* buffer;
1822 int fence_fd;
1823 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001824 if (err != android::OK) {
Chris Forbesfca0f292017-03-30 19:48:39 +13001825 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1826 swapchain_result = WorstPresentResult(swapchain_result,
1827 VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001828 } else if (img.buffer != buffer) {
Chris Forbesfca0f292017-03-30 19:48:39 +13001829 ALOGE("got wrong image back for shared swapchain");
1830 swapchain_result = WorstPresentResult(swapchain_result,
1831 VK_ERROR_SURFACE_LOST_KHR);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001832 } else {
Chris Forbesfca0f292017-03-30 19:48:39 +13001833 img.dequeue_fence = fence_fd;
1834 img.dequeued = true;
1835 }
1836 }
Jesse Halldc225072016-05-30 22:40:14 -07001837 }
1838 if (swapchain_result != VK_SUCCESS) {
Jesse Halldc225072016-05-30 22:40:14 -07001839 OrphanSwapchain(device, &swapchain);
1840 }
silence_dogood73597592019-05-23 16:57:37 -07001841 int window_transform_hint;
1842 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
1843 &window_transform_hint);
Yiwei Zhangf5030b42019-12-19 00:10:04 -08001844 if (err != android::OK) {
silence_dogood73597592019-05-23 16:57:37 -07001845 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1846 strerror(-err), err);
1847 swapchain_result = WorstPresentResult(
1848 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
1849 }
1850 if (swapchain.pre_transform != window_transform_hint) {
1851 swapchain_result =
1852 WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
1853 }
Jesse Halldc225072016-05-30 22:40:14 -07001854 } else {
Yiwei Zhang9df5bff2020-09-22 10:08:03 -07001855 ReleaseSwapchainImage(device, nullptr, fence, img, true);
Jesse Halldc225072016-05-30 22:40:14 -07001856 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001857 }
1858
Jesse Halla9e57032015-11-30 01:03:10 -08001859 if (present_info->pResults)
Jesse Halldc225072016-05-30 22:40:14 -07001860 present_info->pResults[sc] = swapchain_result;
1861
1862 if (swapchain_result != final_result)
1863 final_result = WorstPresentResult(final_result, swapchain_result);
Jesse Halld7b994a2015-09-07 14:17:37 -07001864 }
Ian Elliottcb351132016-12-13 10:30:40 -07001865 if (rects) {
1866 allocator->pfnFree(allocator->pUserData, rects);
1867 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001868
1869 return final_result;
1870}
Jesse Hallb1352bc2015-09-04 16:12:33 -07001871
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001872VKAPI_ATTR
1873VkResult GetRefreshCycleDurationGOOGLE(
1874 VkDevice,
Ian Elliott62c48c92017-01-20 13:13:20 -07001875 VkSwapchainKHR swapchain_handle,
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001876 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001877 ATRACE_CALL();
1878
Ian Elliott62c48c92017-01-20 13:13:20 -07001879 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001880 VkResult result = VK_SUCCESS;
1881
Ian Elliott3568bfe2019-05-03 15:54:46 -06001882 pDisplayTimingProperties->refreshDuration = swapchain.get_refresh_duration();
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001883
1884 return result;
1885}
1886
1887VKAPI_ATTR
1888VkResult GetPastPresentationTimingGOOGLE(
1889 VkDevice,
1890 VkSwapchainKHR swapchain_handle,
1891 uint32_t* count,
1892 VkPastPresentationTimingGOOGLE* timings) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001893 ATRACE_CALL();
1894
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001895 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001896 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1897 return VK_ERROR_OUT_OF_DATE_KHR;
1898 }
1899
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001900 ANativeWindow* window = swapchain.surface.window.get();
1901 VkResult result = VK_SUCCESS;
1902
1903 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001904 ALOGV("Calling native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001905 native_window_enable_frame_timestamps(window, true);
1906 swapchain.frame_timestamps_enabled = true;
1907 }
1908
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001909 if (timings) {
Yiwei Zhang9d187832019-07-22 15:15:47 -07001910 // Get the latest ready timing count before copying, since the copied
1911 // timing info will be erased in copy_ready_timings function.
1912 uint32_t n = get_num_ready_timings(swapchain);
Ian Elliott8a977262017-01-19 09:05:58 -07001913 copy_ready_timings(swapchain, count, timings);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001914 // Check the *count here against the recorded ready timing count, since
1915 // *count can be overwritten per spec describes.
1916 if (*count < n) {
1917 result = VK_INCOMPLETE;
1918 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001919 } else {
Ian Elliott8a977262017-01-19 09:05:58 -07001920 *count = get_num_ready_timings(swapchain);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001921 }
1922
1923 return result;
1924}
1925
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001926VKAPI_ATTR
1927VkResult GetSwapchainStatusKHR(
1928 VkDevice,
Chris Forbes4e18ba82017-01-20 12:50:17 +13001929 VkSwapchainKHR swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001930 ATRACE_CALL();
1931
Chris Forbes4e18ba82017-01-20 12:50:17 +13001932 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001933 VkResult result = VK_SUCCESS;
1934
Chris Forbes4e18ba82017-01-20 12:50:17 +13001935 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1936 return VK_ERROR_OUT_OF_DATE_KHR;
1937 }
1938
Yiwei Zhanga885c062019-10-24 12:07:57 -07001939 // TODO(b/143296009): Implement this function properly
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001940
1941 return result;
1942}
1943
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001944VKAPI_ATTR void SetHdrMetadataEXT(
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001945 VkDevice,
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001946 uint32_t swapchainCount,
1947 const VkSwapchainKHR* pSwapchains,
1948 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001949 ATRACE_CALL();
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001950
1951 for (uint32_t idx = 0; idx < swapchainCount; idx++) {
1952 Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);
1953 if (!swapchain)
1954 continue;
1955
1956 if (swapchain->surface.swapchain_handle != pSwapchains[idx]) continue;
1957
1958 ANativeWindow* window = swapchain->surface.window.get();
1959
1960 VkHdrMetadataEXT vulkanMetadata = pHdrMetadataEXTs[idx];
1961 const android_smpte2086_metadata smpteMetdata = {
1962 {vulkanMetadata.displayPrimaryRed.x,
1963 vulkanMetadata.displayPrimaryRed.y},
1964 {vulkanMetadata.displayPrimaryGreen.x,
1965 vulkanMetadata.displayPrimaryGreen.y},
1966 {vulkanMetadata.displayPrimaryBlue.x,
1967 vulkanMetadata.displayPrimaryBlue.y},
1968 {vulkanMetadata.whitePoint.x, vulkanMetadata.whitePoint.y},
1969 vulkanMetadata.maxLuminance,
1970 vulkanMetadata.minLuminance};
1971 native_window_set_buffers_smpte2086_metadata(window, &smpteMetdata);
1972
1973 const android_cta861_3_metadata cta8613Metadata = {
1974 vulkanMetadata.maxContentLightLevel,
1975 vulkanMetadata.maxFrameAverageLightLevel};
1976 native_window_set_buffers_cta861_3_metadata(window, &cta8613Metadata);
1977 }
1978
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001979 return;
1980}
1981
Yiwei Zhang0f475222019-04-11 19:38:00 -07001982static void InterceptBindImageMemory2(
1983 uint32_t bind_info_count,
1984 const VkBindImageMemoryInfo* bind_infos,
1985 std::vector<VkNativeBufferANDROID>* out_native_buffers,
1986 std::vector<VkBindImageMemoryInfo>* out_bind_infos) {
1987 out_native_buffers->clear();
1988 out_bind_infos->clear();
1989
1990 if (!bind_info_count)
1991 return;
1992
1993 std::unordered_set<uint32_t> intercepted_indexes;
1994
1995 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1996 auto info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1997 bind_infos[idx].pNext);
1998 while (info &&
1999 info->sType !=
2000 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR) {
2001 info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
2002 info->pNext);
2003 }
2004
2005 if (!info)
2006 continue;
2007
2008 ALOG_ASSERT(info->swapchain != VK_NULL_HANDLE,
2009 "swapchain handle must not be NULL");
2010 const Swapchain* swapchain = SwapchainFromHandle(info->swapchain);
2011 ALOG_ASSERT(
2012 info->imageIndex < swapchain->num_images,
2013 "imageIndex must be less than the number of images in swapchain");
2014
2015 ANativeWindowBuffer* buffer =
2016 swapchain->images[info->imageIndex].buffer.get();
2017 VkNativeBufferANDROID native_buffer = {
2018#pragma clang diagnostic push
2019#pragma clang diagnostic ignored "-Wold-style-cast"
2020 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
2021#pragma clang diagnostic pop
2022 .pNext = bind_infos[idx].pNext,
2023 .handle = buffer->handle,
2024 .stride = buffer->stride,
2025 .format = buffer->format,
2026 .usage = int(buffer->usage),
2027 };
2028 // Reserve enough space to avoid letting re-allocation invalidate the
2029 // addresses of the elements inside.
2030 out_native_buffers->reserve(bind_info_count);
2031 out_native_buffers->emplace_back(native_buffer);
2032
2033 // Reserve the space now since we know how much is needed now.
2034 out_bind_infos->reserve(bind_info_count);
2035 out_bind_infos->emplace_back(bind_infos[idx]);
2036 out_bind_infos->back().pNext = &out_native_buffers->back();
2037
2038 intercepted_indexes.insert(idx);
2039 }
2040
2041 if (intercepted_indexes.empty())
2042 return;
2043
2044 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
2045 if (intercepted_indexes.count(idx))
2046 continue;
2047 out_bind_infos->emplace_back(bind_infos[idx]);
2048 }
2049}
2050
Yiwei Zhang23143102019-04-10 18:24:05 -07002051VKAPI_ATTR
2052VkResult BindImageMemory2(VkDevice device,
2053 uint32_t bindInfoCount,
2054 const VkBindImageMemoryInfo* pBindInfos) {
2055 ATRACE_CALL();
2056
Yiwei Zhang0f475222019-04-11 19:38:00 -07002057 // out_native_buffers is for maintaining the lifecycle of the constructed
2058 // VkNativeBufferANDROID objects inside InterceptBindImageMemory2.
2059 std::vector<VkNativeBufferANDROID> out_native_buffers;
2060 std::vector<VkBindImageMemoryInfo> out_bind_infos;
2061 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
2062 &out_bind_infos);
2063 return GetData(device).driver.BindImageMemory2(
2064 device, bindInfoCount,
2065 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07002066}
2067
2068VKAPI_ATTR
2069VkResult BindImageMemory2KHR(VkDevice device,
2070 uint32_t bindInfoCount,
2071 const VkBindImageMemoryInfo* pBindInfos) {
2072 ATRACE_CALL();
2073
Yiwei Zhang0f475222019-04-11 19:38:00 -07002074 std::vector<VkNativeBufferANDROID> out_native_buffers;
2075 std::vector<VkBindImageMemoryInfo> out_bind_infos;
2076 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
2077 &out_bind_infos);
2078 return GetData(device).driver.BindImageMemory2KHR(
2079 device, bindInfoCount,
2080 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07002081}
2082
Chia-I Wu62262232016-03-26 07:06:44 +08002083} // namespace driver
Jesse Hallb1352bc2015-09-04 16:12:33 -07002084} // namespace vulkan