blob: a020e744cdd4ecf76ed2031a745e4e0643a03a0f [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 Zhangfdd0c2a2019-01-30 20:16:37 -080027#include <utils/Trace.h>
Yiwei Zhang0f475222019-04-11 19:38:00 -070028
29#include <algorithm>
30#include <unordered_set>
31#include <vector>
Jesse Halld7b994a2015-09-07 14:17:37 -070032
Chia-I Wu4a6a9162016-03-26 07:17:34 +080033#include "driver.h"
Jesse Halld7b994a2015-09-07 14:17:37 -070034
Daniel Kochf25f5bb2017-10-05 00:26:58 -040035using android::hardware::graphics::common::V1_0::BufferUsage;
36
Chia-I Wu62262232016-03-26 07:06:44 +080037namespace vulkan {
38namespace driver {
Jesse Hall5ae3abb2015-10-08 14:00:22 -070039
Jesse Halld7b994a2015-09-07 14:17:37 -070040namespace {
41
Jesse Hall55bc0972016-02-23 16:43:29 -080042const VkSurfaceTransformFlagsKHR kSupportedTransforms =
43 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
44 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
45 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
46 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
Yiwei Zhang70a21962019-05-31 17:26:52 -070047 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
48 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
49 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
50 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
Jesse Hall55bc0972016-02-23 16:43:29 -080051 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
52
53VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
54 // Native and Vulkan transforms are isomorphic, but are represented
55 // differently. Vulkan transforms are built up of an optional horizontal
56 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
57 // transforms are built up from a horizontal flip, vertical flip, and
58 // 90-degree rotation, all optional but always in that order.
59
Jesse Hall55bc0972016-02-23 16:43:29 -080060 switch (native) {
Yiwei Zhang70a21962019-05-31 17:26:52 -070061 case 0:
Jesse Hall55bc0972016-02-23 16:43:29 -080062 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070063 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
64 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
65 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
66 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
67 case NATIVE_WINDOW_TRANSFORM_ROT_180:
Jesse Hall55bc0972016-02-23 16:43:29 -080068 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070069 case NATIVE_WINDOW_TRANSFORM_ROT_90:
Jesse Hall55bc0972016-02-23 16:43:29 -080070 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
Yiwei Zhang70a21962019-05-31 17:26:52 -070071 case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
72 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
73 case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
74 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
75 case NATIVE_WINDOW_TRANSFORM_ROT_270:
Jesse Hall55bc0972016-02-23 16:43:29 -080076 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
77 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
78 default:
79 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
80 }
81}
82
Yiwei Zhang70a21962019-05-31 17:26:52 -070083int TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform) {
84 switch (transform) {
85 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
86 return NATIVE_WINDOW_TRANSFORM_ROT_90;
87 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
88 return NATIVE_WINDOW_TRANSFORM_ROT_180;
89 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
90 return NATIVE_WINDOW_TRANSFORM_ROT_270;
91 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
92 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
93 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
94 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
95 NATIVE_WINDOW_TRANSFORM_ROT_90;
96 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
97 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
98 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
99 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
100 NATIVE_WINDOW_TRANSFORM_ROT_90;
101 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
102 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
103 default:
104 return 0;
105 }
106}
107
Jesse Hall178b6962016-02-24 15:39:50 -0800108int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
109 switch (transform) {
110 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
111 return NATIVE_WINDOW_TRANSFORM_ROT_270;
112 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
113 return NATIVE_WINDOW_TRANSFORM_ROT_180;
114 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
115 return NATIVE_WINDOW_TRANSFORM_ROT_90;
Yiwei Zhang70a21962019-05-31 17:26:52 -0700116 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
117 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
118 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
119 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
120 NATIVE_WINDOW_TRANSFORM_ROT_90;
121 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
122 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
123 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
124 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
125 NATIVE_WINDOW_TRANSFORM_ROT_90;
Jesse Hall178b6962016-02-24 15:39:50 -0800126 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
127 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
128 default:
129 return 0;
130 }
131}
132
Ian Elliott8a977262017-01-19 09:05:58 -0700133class TimingInfo {
134 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800135 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
Ian Elliott2c6355d2017-01-19 11:02:13 -0700136 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
Brian Anderson1049d1d2016-12-16 17:25:57 -0800137 native_frame_id_(nativeFrameId) {}
138 bool ready() const {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700139 return (timestamp_desired_present_time_ !=
140 NATIVE_WINDOW_TIMESTAMP_PENDING &&
141 timestamp_actual_present_time_ !=
142 NATIVE_WINDOW_TIMESTAMP_PENDING &&
143 timestamp_render_complete_time_ !=
144 NATIVE_WINDOW_TIMESTAMP_PENDING &&
145 timestamp_composition_latch_time_ !=
146 NATIVE_WINDOW_TIMESTAMP_PENDING);
Ian Elliott8a977262017-01-19 09:05:58 -0700147 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700148 void calculate(int64_t rdur) {
149 bool anyTimestampInvalid =
150 (timestamp_actual_present_time_ ==
151 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
152 (timestamp_render_complete_time_ ==
153 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
154 (timestamp_composition_latch_time_ ==
155 NATIVE_WINDOW_TIMESTAMP_INVALID);
156 if (anyTimestampInvalid) {
157 ALOGE("Unexpectedly received invalid timestamp.");
158 vals_.actualPresentTime = 0;
159 vals_.earliestPresentTime = 0;
160 vals_.presentMargin = 0;
161 return;
162 }
163
164 vals_.actualPresentTime =
165 static_cast<uint64_t>(timestamp_actual_present_time_);
166 int64_t margin = (timestamp_composition_latch_time_ -
Ian Elliott8a977262017-01-19 09:05:58 -0700167 timestamp_render_complete_time_);
168 // Calculate vals_.earliestPresentTime, and potentially adjust
169 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
170 // is vals_.actualPresentTime. If we can subtract rdur (the duration
171 // of a refresh cycle) from vals_.earliestPresentTime (and also from
172 // vals_.presentMargin) and still leave a positive margin, then we can
173 // report to the application that it could have presented earlier than
174 // it did (per the extension specification). If for some reason, we
175 // can do this subtraction repeatedly, we do, since
176 // vals_.earliestPresentTime really is supposed to be the "earliest".
Brian Andersondc96fdf2017-03-20 16:54:25 -0700177 int64_t early_time = timestamp_actual_present_time_;
Ian Elliott8a977262017-01-19 09:05:58 -0700178 while ((margin > rdur) &&
179 ((early_time - rdur) > timestamp_composition_latch_time_)) {
180 early_time -= rdur;
181 margin -= rdur;
182 }
Brian Andersondc96fdf2017-03-20 16:54:25 -0700183 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
184 vals_.presentMargin = static_cast<uint64_t>(margin);
Ian Elliott8a977262017-01-19 09:05:58 -0700185 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800186 void get_values(VkPastPresentationTimingGOOGLE* values) const {
187 *values = vals_;
188 }
Ian Elliott8a977262017-01-19 09:05:58 -0700189
190 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800191 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700192
Brian Anderson1049d1d2016-12-16 17:25:57 -0800193 uint64_t native_frame_id_ { 0 };
Brian Andersondc96fdf2017-03-20 16:54:25 -0700194 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
195 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
196 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
197 int64_t timestamp_composition_latch_time_
198 { NATIVE_WINDOW_TIMESTAMP_PENDING };
Ian Elliott8a977262017-01-19 09:05:58 -0700199};
200
Jesse Hall1356b0d2015-11-23 17:24:58 -0800201struct Surface {
Chia-I Wue8e689f2016-04-18 08:21:31 +0800202 android::sp<ANativeWindow> window;
Jesse Halldc225072016-05-30 22:40:14 -0700203 VkSwapchainKHR swapchain_handle;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700204 uint64_t consumer_usage;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800205};
206
207VkSurfaceKHR HandleFromSurface(Surface* surface) {
208 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
209}
210
211Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800212 return reinterpret_cast<Surface*>(handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800213}
214
Ian Elliott8a977262017-01-19 09:05:58 -0700215// Maximum number of TimingInfo structs to keep per swapchain:
216enum { MAX_TIMING_INFOS = 10 };
217// Minimum number of frames to look for in the past (so we don't cause
218// syncronous requests to Surface Flinger):
219enum { MIN_NUM_FRAMES_AGO = 5 };
220
Jesse Hall1356b0d2015-11-23 17:24:58 -0800221struct Swapchain {
Ian Elliottffedb652017-02-14 10:58:30 -0700222 Swapchain(Surface& surface_,
223 uint32_t num_images_,
silence_dogood73597592019-05-23 16:57:37 -0700224 VkPresentModeKHR present_mode,
225 int pre_transform_)
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700226 : surface(surface_),
227 num_images(num_images_),
Ian Elliottffedb652017-02-14 10:58:30 -0700228 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
silence_dogood73597592019-05-23 16:57:37 -0700229 pre_transform(pre_transform_),
Chris Forbesf8835642017-03-30 19:31:40 +1300230 frame_timestamps_enabled(false),
231 shared(present_mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
232 present_mode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Ian Elliott62c48c92017-01-20 13:13:20 -0700233 ANativeWindow* window = surface.window.get();
Ian Elliottbe833a22017-01-25 13:09:20 -0700234 native_window_get_refresh_cycle_duration(
Ian Elliott62c48c92017-01-20 13:13:20 -0700235 window,
Brian Andersondc96fdf2017-03-20 16:54:25 -0700236 &refresh_duration);
Ian Elliott8a977262017-01-19 09:05:58 -0700237 }
Ian Elliott3568bfe2019-05-03 15:54:46 -0600238 uint64_t get_refresh_duration()
239 {
240 ANativeWindow* window = surface.window.get();
241 native_window_get_refresh_cycle_duration(
242 window,
243 &refresh_duration);
244 return static_cast<uint64_t>(refresh_duration);
245
246 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800247
248 Surface& surface;
Jesse Halld7b994a2015-09-07 14:17:37 -0700249 uint32_t num_images;
Ian Elliottffedb652017-02-14 10:58:30 -0700250 bool mailbox_mode;
silence_dogood73597592019-05-23 16:57:37 -0700251 int pre_transform;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700252 bool frame_timestamps_enabled;
Brian Andersondc96fdf2017-03-20 16:54:25 -0700253 int64_t refresh_duration;
Chris Forbesf8835642017-03-30 19:31:40 +1300254 bool shared;
Jesse Halld7b994a2015-09-07 14:17:37 -0700255
256 struct Image {
257 Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
258 VkImage image;
Chia-I Wue8e689f2016-04-18 08:21:31 +0800259 android::sp<ANativeWindowBuffer> buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -0700260 // The fence is only valid when the buffer is dequeued, and should be
261 // -1 any other time. When valid, we own the fd, and must ensure it is
262 // closed: either by closing it explicitly when queueing the buffer,
263 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
264 int dequeue_fence;
265 bool dequeued;
Pawin Vongmasa6e1193a2017-03-07 13:08:40 -0800266 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
Ian Elliott8a977262017-01-19 09:05:58 -0700267
Yiwei Zhang5e862202019-06-21 14:59:16 -0700268 std::vector<TimingInfo> timing;
Jesse Halld7b994a2015-09-07 14:17:37 -0700269};
270
271VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
272 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
273}
274
275Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800276 return reinterpret_cast<Swapchain*>(handle);
Jesse Halld7b994a2015-09-07 14:17:37 -0700277}
278
Jesse Halldc225072016-05-30 22:40:14 -0700279void ReleaseSwapchainImage(VkDevice device,
280 ANativeWindow* window,
281 int release_fence,
282 Swapchain::Image& image) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700283 ATRACE_CALL();
284
Jesse Halldc225072016-05-30 22:40:14 -0700285 ALOG_ASSERT(release_fence == -1 || image.dequeued,
286 "ReleaseSwapchainImage: can't provide a release fence for "
287 "non-dequeued images");
288
289 if (image.dequeued) {
290 if (release_fence >= 0) {
291 // We get here from vkQueuePresentKHR. The application is
292 // responsible for creating an execution dependency chain from
293 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
294 // (release_fence), so we can drop the dequeue_fence here.
295 if (image.dequeue_fence >= 0)
296 close(image.dequeue_fence);
297 } else {
298 // We get here during swapchain destruction, or various serious
299 // error cases e.g. when we can't create the release_fence during
300 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
301 // have already signalled, since the swapchain images are supposed
302 // to be idle before the swapchain is destroyed. In error cases,
303 // there may be rendering in flight to the image, but since we
304 // weren't able to create a release_fence, waiting for the
305 // dequeue_fence is about the best we can do.
306 release_fence = image.dequeue_fence;
307 }
308 image.dequeue_fence = -1;
309
310 if (window) {
311 window->cancelBuffer(window, image.buffer.get(), release_fence);
312 } else {
313 if (release_fence >= 0) {
314 sync_wait(release_fence, -1 /* forever */);
315 close(release_fence);
316 }
317 }
318
319 image.dequeued = false;
320 }
321
322 if (image.image) {
Yiwei Zhang533cea92019-06-03 18:43:24 -0700323 ATRACE_BEGIN("DestroyImage");
Jesse Halldc225072016-05-30 22:40:14 -0700324 GetData(device).driver.DestroyImage(device, image.image, nullptr);
Yiwei Zhang533cea92019-06-03 18:43:24 -0700325 ATRACE_END();
Jesse Halldc225072016-05-30 22:40:14 -0700326 image.image = VK_NULL_HANDLE;
327 }
328
329 image.buffer.clear();
330}
331
332void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
333 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
334 return;
Jesse Halldc225072016-05-30 22:40:14 -0700335 for (uint32_t i = 0; i < swapchain->num_images; i++) {
336 if (!swapchain->images[i].dequeued)
337 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i]);
338 }
339 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Ian Elliott8a977262017-01-19 09:05:58 -0700340 swapchain->timing.clear();
341}
342
343uint32_t get_num_ready_timings(Swapchain& swapchain) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800344 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
345 return 0;
346 }
Ian Elliott8a977262017-01-19 09:05:58 -0700347
Brian Anderson1049d1d2016-12-16 17:25:57 -0800348 uint32_t num_ready = 0;
349 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
350 for (uint32_t i = 0; i < num_timings; i++) {
Yiwei Zhang5e862202019-06-21 14:59:16 -0700351 TimingInfo& ti = swapchain.timing[i];
Brian Anderson1049d1d2016-12-16 17:25:57 -0800352 if (ti.ready()) {
353 // This TimingInfo is ready to be reported to the user. Add it
354 // to the num_ready.
355 num_ready++;
356 continue;
357 }
358 // This TimingInfo is not yet ready to be reported to the user,
359 // and so we should look for any available timestamps that
360 // might make it ready.
361 int64_t desired_present_time = 0;
362 int64_t render_complete_time = 0;
363 int64_t composition_latch_time = 0;
364 int64_t actual_present_time = 0;
365 // Obtain timestamps:
366 int ret = native_window_get_frame_timestamps(
367 swapchain.surface.window.get(), ti.native_frame_id_,
368 &desired_present_time, &render_complete_time,
369 &composition_latch_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700370 nullptr, //&first_composition_start_time,
371 nullptr, //&last_composition_start_time,
372 nullptr, //&composition_finish_time,
Brian Anderson1049d1d2016-12-16 17:25:57 -0800373 &actual_present_time,
Yi Kongbcbc73a2018-07-18 10:13:04 -0700374 nullptr, //&dequeue_ready_time,
375 nullptr /*&reads_done_time*/);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800376
377 if (ret != android::NO_ERROR) {
378 continue;
379 }
380
381 // Record the timestamp(s) we received, and then see if this TimingInfo
382 // is ready to be reported to the user:
Brian Andersondc96fdf2017-03-20 16:54:25 -0700383 ti.timestamp_desired_present_time_ = desired_present_time;
384 ti.timestamp_actual_present_time_ = actual_present_time;
385 ti.timestamp_render_complete_time_ = render_complete_time;
386 ti.timestamp_composition_latch_time_ = composition_latch_time;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800387
388 if (ti.ready()) {
389 // The TimingInfo has received enough timestamps, and should now
390 // use those timestamps to calculate the info that should be
391 // reported to the user:
392 ti.calculate(swapchain.refresh_duration);
393 num_ready++;
Ian Elliott8a977262017-01-19 09:05:58 -0700394 }
395 }
396 return num_ready;
397}
398
Ian Elliott8a977262017-01-19 09:05:58 -0700399void copy_ready_timings(Swapchain& swapchain,
400 uint32_t* count,
401 VkPastPresentationTimingGOOGLE* timings) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800402 if (swapchain.timing.empty()) {
403 *count = 0;
404 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700405 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800406
407 size_t last_ready = swapchain.timing.size() - 1;
408 while (!swapchain.timing[last_ready].ready()) {
409 if (last_ready == 0) {
410 *count = 0;
411 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700412 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800413 last_ready--;
Ian Elliott8a977262017-01-19 09:05:58 -0700414 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800415
416 uint32_t num_copied = 0;
Yiwei Zhang5e862202019-06-21 14:59:16 -0700417 int32_t num_to_remove = 0;
Brian Anderson1049d1d2016-12-16 17:25:57 -0800418 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
419 const TimingInfo& ti = swapchain.timing[i];
420 if (ti.ready()) {
421 ti.get_values(&timings[num_copied]);
422 num_copied++;
423 }
424 num_to_remove++;
425 }
426
427 // Discard old frames that aren't ready if newer frames are ready.
428 // We don't expect to get the timing info for those old frames.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700429 swapchain.timing.erase(swapchain.timing.begin(),
430 swapchain.timing.begin() + num_to_remove);
Brian Anderson1049d1d2016-12-16 17:25:57 -0800431
Ian Elliott8a977262017-01-19 09:05:58 -0700432 *count = num_copied;
Jesse Halldc225072016-05-30 22:40:14 -0700433}
434
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700435android_pixel_format GetNativePixelFormat(VkFormat format) {
436 android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
437 switch (format) {
438 case VK_FORMAT_R8G8B8A8_UNORM:
439 case VK_FORMAT_R8G8B8A8_SRGB:
440 native_format = HAL_PIXEL_FORMAT_RGBA_8888;
441 break;
442 case VK_FORMAT_R5G6B5_UNORM_PACK16:
443 native_format = HAL_PIXEL_FORMAT_RGB_565;
444 break;
445 case VK_FORMAT_R16G16B16A16_SFLOAT:
446 native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
447 break;
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800448 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700449 native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
450 break;
451 default:
452 ALOGV("unsupported swapchain format %d", format);
453 break;
454 }
455 return native_format;
456}
457
458android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
459 switch (colorspace) {
460 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
461 return HAL_DATASPACE_V0_SRGB;
462 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
463 return HAL_DATASPACE_DISPLAY_P3;
464 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
465 return HAL_DATASPACE_V0_SCRGB_LINEAR;
Courtney Goeltzenleuchterb52abee2017-08-07 17:13:04 -0600466 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
467 return HAL_DATASPACE_V0_SCRGB;
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700468 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
469 return HAL_DATASPACE_DCI_P3_LINEAR;
470 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
471 return HAL_DATASPACE_DCI_P3;
472 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
473 return HAL_DATASPACE_V0_SRGB_LINEAR;
474 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
475 return HAL_DATASPACE_V0_SRGB;
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600476 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
477 return HAL_DATASPACE_BT2020_LINEAR;
478 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700479 return static_cast<android_dataspace>(
480 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
481 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchterc45673f2017-03-13 15:58:15 -0600482 case VK_COLOR_SPACE_DOLBYVISION_EXT:
483 return static_cast<android_dataspace>(
484 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
485 HAL_DATASPACE_RANGE_FULL);
486 case VK_COLOR_SPACE_HDR10_HLG_EXT:
487 return static_cast<android_dataspace>(
488 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_HLG |
489 HAL_DATASPACE_RANGE_FULL);
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700490 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
491 return static_cast<android_dataspace>(
492 HAL_DATASPACE_STANDARD_ADOBE_RGB |
493 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
494 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
495 return HAL_DATASPACE_ADOBE_RGB;
496
497 // Pass through is intended to allow app to provide data that is passed
498 // to the display system without modification.
499 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
500 return HAL_DATASPACE_ARBITRARY;
501
502 default:
503 // This indicates that we don't know about the
504 // dataspace specified and we should indicate that
505 // it's unsupported
506 return HAL_DATASPACE_UNKNOWN;
507 }
508}
509
Jesse Halld7b994a2015-09-07 14:17:37 -0700510} // anonymous namespace
Jesse Hallb1352bc2015-09-04 16:12:33 -0700511
Jesse Halle1b12782015-11-30 11:27:32 -0800512VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800513VkResult CreateAndroidSurfaceKHR(
Jesse Hallf9fa9a52016-01-08 16:08:51 -0800514 VkInstance instance,
515 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
516 const VkAllocationCallbacks* allocator,
517 VkSurfaceKHR* out_surface) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800518 ATRACE_CALL();
519
Jesse Hall1f91d392015-12-11 16:28:44 -0800520 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800521 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800522 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
523 alignof(Surface),
524 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800525 if (!mem)
526 return VK_ERROR_OUT_OF_HOST_MEMORY;
527 Surface* surface = new (mem) Surface;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700528
Chia-I Wue8e689f2016-04-18 08:21:31 +0800529 surface->window = pCreateInfo->window;
Jesse Halldc225072016-05-30 22:40:14 -0700530 surface->swapchain_handle = VK_NULL_HANDLE;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700531 int err = native_window_get_consumer_usage(surface->window.get(),
532 &surface->consumer_usage);
533 if (err != android::NO_ERROR) {
534 ALOGE("native_window_get_consumer_usage() failed: %s (%d)",
535 strerror(-err), err);
536 surface->~Surface();
537 allocator->pfnFree(allocator->pUserData, surface);
Yiwei Zhang70a21962019-05-31 17:26:52 -0700538 return VK_ERROR_SURFACE_LOST_KHR;
Yiwei Zhang6435b322018-05-08 11:12:17 -0700539 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700540
Yiwei Zhang6435b322018-05-08 11:12:17 -0700541 err =
Jesse Hall1356b0d2015-11-23 17:24:58 -0800542 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
543 if (err != 0) {
Jesse Hall1356b0d2015-11-23 17:24:58 -0800544 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
545 err);
546 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800547 allocator->pfnFree(allocator->pUserData, surface);
Mike Stroyan762c8132017-02-22 11:43:09 -0700548 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800549 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700550
Jesse Hall1356b0d2015-11-23 17:24:58 -0800551 *out_surface = HandleFromSurface(surface);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700552 return VK_SUCCESS;
553}
554
Jesse Halle1b12782015-11-30 11:27:32 -0800555VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800556void DestroySurfaceKHR(VkInstance instance,
557 VkSurfaceKHR surface_handle,
558 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800559 ATRACE_CALL();
560
Jesse Hall1356b0d2015-11-23 17:24:58 -0800561 Surface* surface = SurfaceFromHandle(surface_handle);
562 if (!surface)
563 return;
564 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700565 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
Jesse Halldc225072016-05-30 22:40:14 -0700566 "destroyed VkSurfaceKHR 0x%" PRIx64
567 " has active VkSwapchainKHR 0x%" PRIx64,
568 reinterpret_cast<uint64_t>(surface_handle),
569 reinterpret_cast<uint64_t>(surface->swapchain_handle));
Jesse Hall1356b0d2015-11-23 17:24:58 -0800570 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800571 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800572 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800573 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800574}
575
Jesse Halle1b12782015-11-30 11:27:32 -0800576VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800577VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
578 uint32_t /*queue_family*/,
Yiwei Zhang6435b322018-05-08 11:12:17 -0700579 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800580 VkBool32* supported) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800581 ATRACE_CALL();
582
Yiwei Zhang6435b322018-05-08 11:12:17 -0700583 const Surface* surface = SurfaceFromHandle(surface_handle);
584 if (!surface) {
585 return VK_ERROR_SURFACE_LOST_KHR;
586 }
587 const ANativeWindow* window = surface->window.get();
588
589 int query_value;
590 int err = window->query(window, NATIVE_WINDOW_FORMAT, &query_value);
591 if (err != 0 || query_value < 0) {
592 ALOGE("NATIVE_WINDOW_FORMAT query failed: %s (%d) value=%d",
593 strerror(-err), err, query_value);
594 return VK_ERROR_SURFACE_LOST_KHR;
595 }
596
597 android_pixel_format native_format =
598 static_cast<android_pixel_format>(query_value);
599
600 bool format_supported = false;
601 switch (native_format) {
602 case HAL_PIXEL_FORMAT_RGBA_8888:
603 case HAL_PIXEL_FORMAT_RGB_565:
Yiwei Zhang5979cb52018-09-25 16:47:07 -0700604 case HAL_PIXEL_FORMAT_RGBA_FP16:
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800605 case HAL_PIXEL_FORMAT_RGBA_1010102:
Yiwei Zhang6435b322018-05-08 11:12:17 -0700606 format_supported = true;
607 break;
608 default:
609 break;
610 }
611
Yiwei Zhangc91b9b72018-06-07 11:13:27 -0700612 *supported = static_cast<VkBool32>(
613 format_supported || (surface->consumer_usage &
614 (AHARDWAREBUFFER_USAGE_CPU_READ_MASK |
615 AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) == 0);
Yiwei Zhang6435b322018-05-08 11:12:17 -0700616
Jesse Halla6429252015-11-29 18:59:42 -0800617 return VK_SUCCESS;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800618}
619
Jesse Halle1b12782015-11-30 11:27:32 -0800620VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800621VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
Jesse Hallb00daad2015-11-29 19:46:20 -0800622 VkPhysicalDevice /*pdev*/,
623 VkSurfaceKHR surface,
624 VkSurfaceCapabilitiesKHR* capabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800625 ATRACE_CALL();
626
Jesse Halld7b994a2015-09-07 14:17:37 -0700627 int err;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800628 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -0700629
630 int width, height;
631 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
632 if (err != 0) {
633 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
634 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700635 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700636 }
637 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
638 if (err != 0) {
639 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
640 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700641 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700642 }
643
Jesse Hall55bc0972016-02-23 16:43:29 -0800644 int transform_hint;
645 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
646 if (err != 0) {
647 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
648 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -0700649 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall55bc0972016-02-23 16:43:29 -0800650 }
651
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800652 int max_buffer_count;
653 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count);
654 if (err != 0) {
655 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
656 strerror(-err), err);
657 return VK_ERROR_SURFACE_LOST_KHR;
658 }
Yiwei Zhang8e951d52018-04-12 13:19:46 -0700659 capabilities->minImageCount = max_buffer_count == 1 ? 1 : 2;
Yiwei Zhangdbd96152018-02-08 14:22:53 -0800660 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
Jesse Halld7b994a2015-09-07 14:17:37 -0700661
Jesse Hallfe2662d2016-02-09 13:26:59 -0800662 capabilities->currentExtent =
663 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
664
Yiwei Zhang70a21962019-05-31 17:26:52 -0700665 // TODO(http://b/134182502): Figure out what the max extent should be.
Jesse Hallb00daad2015-11-29 19:46:20 -0800666 capabilities->minImageExtent = VkExtent2D{1, 1};
667 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
Jesse Halld7b994a2015-09-07 14:17:37 -0700668
Jesse Hallfe2662d2016-02-09 13:26:59 -0800669 capabilities->maxImageArrayLayers = 1;
670
Jesse Hall55bc0972016-02-23 16:43:29 -0800671 capabilities->supportedTransforms = kSupportedTransforms;
672 capabilities->currentTransform =
673 TranslateNativeToVulkanTransform(transform_hint);
Jesse Halld7b994a2015-09-07 14:17:37 -0700674
Jesse Hallfe2662d2016-02-09 13:26:59 -0800675 // On Android, window composition is a WindowManager property, not something
676 // associated with the bufferqueue. It can't be changed from here.
677 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700678
Jesse Hallb00daad2015-11-29 19:46:20 -0800679 capabilities->supportedUsageFlags =
Jesse Hall3fbc8562015-11-29 22:10:52 -0800680 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
681 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
682 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
Jesse Halld7b994a2015-09-07 14:17:37 -0700683 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
684
Jesse Hallb1352bc2015-09-04 16:12:33 -0700685 return VK_SUCCESS;
686}
687
Jesse Halle1b12782015-11-30 11:27:32 -0800688VKAPI_ATTR
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700689VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
690 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800691 uint32_t* count,
692 VkSurfaceFormatKHR* formats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800693 ATRACE_CALL();
694
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700695 const InstanceData& instance_data = GetData(pdev);
696
Yiwei Zhanga885c062019-10-24 12:07:57 -0700697 // TODO(b/143296550): Fill out the set of supported formats. Longer term,
698 // add a new gralloc method to query whether a (format, usage) pair is
Jesse Hall1356b0d2015-11-23 17:24:58 -0800699 // supported, and check that for each gralloc format that corresponds to a
700 // Vulkan format. Shorter term, just add a few more formats to the ones
701 // hardcoded below.
Jesse Halld7b994a2015-09-07 14:17:37 -0700702
703 const VkSurfaceFormatKHR kFormats[] = {
Jesse Hall26763382016-05-20 07:13:52 -0700704 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
705 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
706 {VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Jesse Halld7b994a2015-09-07 14:17:37 -0700707 };
708 const uint32_t kNumFormats = sizeof(kFormats) / sizeof(kFormats[0]);
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700709 uint32_t total_num_formats = kNumFormats;
710
711 bool wide_color_support = false;
712 Surface& surface = *SurfaceFromHandle(surface_handle);
713 int err = native_window_get_wide_color_support(surface.window.get(),
714 &wide_color_support);
715 if (err) {
Yiwei Zhang70a21962019-05-31 17:26:52 -0700716 return VK_ERROR_SURFACE_LOST_KHR;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700717 }
718 ALOGV("wide_color_support is: %d", wide_color_support);
719 wide_color_support =
720 wide_color_support &&
721 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
722
723 const VkSurfaceFormatKHR kWideColorFormats[] = {
Courtney Goeltzenleuchterbd7e03a2017-09-28 11:34:18 -0600724 {VK_FORMAT_R8G8B8A8_UNORM,
725 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT},
726 {VK_FORMAT_R8G8B8A8_SRGB,
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700727 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT},
Yiwei Zhang5979cb52018-09-25 16:47:07 -0700728 {VK_FORMAT_R16G16B16A16_SFLOAT,
729 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT},
730 {VK_FORMAT_R16G16B16A16_SFLOAT,
731 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT},
Yiwei Zhangc1ea8152019-02-05 15:11:32 -0800732 {VK_FORMAT_A2B10G10R10_UNORM_PACK32,
733 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT},
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700734 };
735 const uint32_t kNumWideColorFormats =
736 sizeof(kWideColorFormats) / sizeof(kWideColorFormats[0]);
737 if (wide_color_support) {
738 total_num_formats += kNumWideColorFormats;
739 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700740
741 VkResult result = VK_SUCCESS;
742 if (formats) {
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700743 uint32_t out_count = 0;
744 uint32_t transfer_count = 0;
745 if (*count < total_num_formats)
Jesse Halld7b994a2015-09-07 14:17:37 -0700746 result = VK_INCOMPLETE;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700747 transfer_count = std::min(*count, kNumFormats);
748 std::copy(kFormats, kFormats + transfer_count, formats);
749 out_count += transfer_count;
750 if (wide_color_support) {
751 transfer_count = std::min(*count - out_count, kNumWideColorFormats);
752 std::copy(kWideColorFormats, kWideColorFormats + transfer_count,
753 formats + out_count);
754 out_count += transfer_count;
755 }
756 *count = out_count;
Jesse Hall7331e222016-09-15 21:26:01 -0700757 } else {
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700758 *count = total_num_formats;
Jesse Halld7b994a2015-09-07 14:17:37 -0700759 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700760 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700761}
762
Jesse Halle1b12782015-11-30 11:27:32 -0800763VKAPI_ATTR
Chris Forbes2452cf72017-03-16 16:30:17 +1300764VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
765 VkPhysicalDevice physicalDevice,
766 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
767 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800768 ATRACE_CALL();
769
Chris Forbes2452cf72017-03-16 16:30:17 +1300770 VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
771 physicalDevice, pSurfaceInfo->surface,
772 &pSurfaceCapabilities->surfaceCapabilities);
773
Chris Forbes06bc0092017-03-16 16:46:05 +1300774 VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
775 while (caps->pNext) {
776 caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
777
778 switch (caps->sType) {
779 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
780 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
781 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
782 caps);
783 // Claim same set of usage flags are supported for
784 // shared present modes as for other modes.
785 shared_caps->sharedPresentSupportedUsageFlags =
786 pSurfaceCapabilities->surfaceCapabilities
787 .supportedUsageFlags;
788 } break;
789
790 default:
791 // Ignore all other extension structs
792 break;
793 }
794 }
795
Chris Forbes2452cf72017-03-16 16:30:17 +1300796 return result;
797}
798
799VKAPI_ATTR
800VkResult GetPhysicalDeviceSurfaceFormats2KHR(
801 VkPhysicalDevice physicalDevice,
802 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
803 uint32_t* pSurfaceFormatCount,
804 VkSurfaceFormat2KHR* pSurfaceFormats) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800805 ATRACE_CALL();
806
Chris Forbes2452cf72017-03-16 16:30:17 +1300807 if (!pSurfaceFormats) {
808 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
809 pSurfaceInfo->surface,
810 pSurfaceFormatCount, nullptr);
811 } else {
812 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
813 // after the call.
Yiwei Zhang5e862202019-06-21 14:59:16 -0700814 std::vector<VkSurfaceFormatKHR> surface_formats(*pSurfaceFormatCount);
Chris Forbes2452cf72017-03-16 16:30:17 +1300815 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
816 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
Yiwei Zhang5e862202019-06-21 14:59:16 -0700817 surface_formats.data());
Chris Forbes2452cf72017-03-16 16:30:17 +1300818
819 if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
820 // marshal results individually due to stride difference.
821 // completely ignore any chained extension structs.
822 uint32_t formats_to_marshal = *pSurfaceFormatCount;
823 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
824 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
825 }
826 }
827
828 return result;
829 }
830}
831
832VKAPI_ATTR
Chris Forbese8d79a62017-02-22 12:49:18 +1300833VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800834 VkSurfaceKHR surface,
Chia-I Wu62262232016-03-26 07:06:44 +0800835 uint32_t* count,
836 VkPresentModeKHR* modes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800837 ATRACE_CALL();
838
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800839 int err;
840 int query_value;
841 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
842
843 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &query_value);
844 if (err != 0 || query_value < 0) {
845 ALOGE("NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) value=%d",
846 strerror(-err), err, query_value);
847 return VK_ERROR_SURFACE_LOST_KHR;
848 }
849 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
850
851 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
852 if (err != 0 || query_value < 0) {
853 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
854 strerror(-err), err, query_value);
855 return VK_ERROR_SURFACE_LOST_KHR;
856 }
857 uint32_t max_buffer_count = static_cast<uint32_t>(query_value);
858
Yiwei Zhang5e862202019-06-21 14:59:16 -0700859 std::vector<VkPresentModeKHR> present_modes;
Yiwei Zhange4a559c2018-02-15 11:27:36 -0800860 if (min_undequeued_buffers + 1 < max_buffer_count)
861 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
Chris Forbese8d79a62017-02-22 12:49:18 +1300862 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
863
864 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
865 if (QueryPresentationProperties(pdev, &present_properties)) {
866 if (present_properties.sharedImage) {
867 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
868 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
869 }
870 }
871
872 uint32_t num_modes = uint32_t(present_modes.size());
Jesse Halld7b994a2015-09-07 14:17:37 -0700873
874 VkResult result = VK_SUCCESS;
875 if (modes) {
Chris Forbese8d79a62017-02-22 12:49:18 +1300876 if (*count < num_modes)
Jesse Halld7b994a2015-09-07 14:17:37 -0700877 result = VK_INCOMPLETE;
Chris Forbese8d79a62017-02-22 12:49:18 +1300878 *count = std::min(*count, num_modes);
Yiwei Zhang5e862202019-06-21 14:59:16 -0700879 std::copy_n(present_modes.data(), *count, modes);
Jesse Hall7331e222016-09-15 21:26:01 -0700880 } else {
Chris Forbese8d79a62017-02-22 12:49:18 +1300881 *count = num_modes;
Jesse Halld7b994a2015-09-07 14:17:37 -0700882 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700883 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700884}
885
Jesse Halle1b12782015-11-30 11:27:32 -0800886VKAPI_ATTR
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400887VkResult GetDeviceGroupPresentCapabilitiesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -0600888 VkDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400889 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800890 ATRACE_CALL();
891
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400892 ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
893 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
894 "vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
895 "VkDeviceGroupPresentCapabilitiesKHR structure type %d",
896 pDeviceGroupPresentCapabilities->sType);
897
898 memset(pDeviceGroupPresentCapabilities->presentMask, 0,
899 sizeof(pDeviceGroupPresentCapabilities->presentMask));
900
901 // assume device group of size 1
902 pDeviceGroupPresentCapabilities->presentMask[0] = 1 << 0;
903 pDeviceGroupPresentCapabilities->modes =
904 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
905
906 return VK_SUCCESS;
907}
908
909VKAPI_ATTR
910VkResult GetDeviceGroupSurfacePresentModesKHR(
Ian Elliottcd8ad332017-10-13 09:21:12 -0600911 VkDevice,
912 VkSurfaceKHR,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400913 VkDeviceGroupPresentModeFlagsKHR* pModes) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800914 ATRACE_CALL();
915
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400916 *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
917 return VK_SUCCESS;
918}
919
920VKAPI_ATTR
Ian Elliottcd8ad332017-10-13 09:21:12 -0600921VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400922 VkSurfaceKHR surface,
923 uint32_t* pRectCount,
924 VkRect2D* pRects) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -0800925 ATRACE_CALL();
926
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400927 if (!pRects) {
928 *pRectCount = 1;
929 } else {
930 uint32_t count = std::min(*pRectCount, 1u);
931 bool incomplete = *pRectCount < 1;
932
933 *pRectCount = count;
934
935 if (incomplete) {
936 return VK_INCOMPLETE;
937 }
938
939 int err;
940 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
941
942 int width = 0, height = 0;
943 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
944 if (err != 0) {
945 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
946 strerror(-err), err);
947 }
948 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
949 if (err != 0) {
950 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
951 strerror(-err), err);
952 }
953
Yiwei Zhanga885c062019-10-24 12:07:57 -0700954 // TODO(b/143294545): Return something better than "whole window"
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400955 pRects[0].offset.x = 0;
956 pRects[0].offset.y = 0;
957 pRects[0].extent = VkExtent2D{static_cast<uint32_t>(width),
958 static_cast<uint32_t>(height)};
959 }
960 return VK_SUCCESS;
961}
962
Yiwei Zhang533cea92019-06-03 18:43:24 -0700963static void DestroySwapchainInternal(VkDevice device,
964 VkSwapchainKHR swapchain_handle,
965 const VkAllocationCallbacks* allocator) {
966 ATRACE_CALL();
967
968 const auto& dispatch = GetData(device).driver;
969 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
970 if (!swapchain) {
971 return;
972 }
973
974 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
975 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
976
977 if (window && swapchain->frame_timestamps_enabled) {
978 native_window_enable_frame_timestamps(window, false);
979 }
980
981 for (uint32_t i = 0; i < swapchain->num_images; i++) {
982 ReleaseSwapchainImage(device, window, -1, swapchain->images[i]);
983 }
984
985 if (active) {
986 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
987 }
988
989 if (!allocator) {
990 allocator = &GetData(device).allocator;
991 }
992
993 swapchain->~Swapchain();
994 allocator->pfnFree(allocator->pUserData, swapchain);
995}
996
Daniel Kochf25f5bb2017-10-05 00:26:58 -0400997VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800998VkResult CreateSwapchainKHR(VkDevice device,
999 const VkSwapchainCreateInfoKHR* create_info,
1000 const VkAllocationCallbacks* allocator,
1001 VkSwapchainKHR* swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001002 ATRACE_CALL();
1003
Jesse Halld7b994a2015-09-07 14:17:37 -07001004 int err;
1005 VkResult result = VK_SUCCESS;
1006
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001007 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
1008 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
1009 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
1010 " oldSwapchain=0x%" PRIx64,
1011 reinterpret_cast<uint64_t>(create_info->surface),
1012 create_info->minImageCount, create_info->imageFormat,
1013 create_info->imageColorSpace, create_info->imageExtent.width,
1014 create_info->imageExtent.height, create_info->imageUsage,
1015 create_info->preTransform, create_info->presentMode,
1016 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1017
Jesse Hall1f91d392015-12-11 16:28:44 -08001018 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001019 allocator = &GetData(device).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -08001020
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001021 android_pixel_format native_pixel_format =
1022 GetNativePixelFormat(create_info->imageFormat);
1023 android_dataspace native_dataspace =
1024 GetNativeDataspace(create_info->imageColorSpace);
1025 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
1026 ALOGE(
1027 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
1028 "failed: Unsupported color space",
1029 create_info->imageColorSpace);
1030 return VK_ERROR_INITIALIZATION_FAILED;
1031 }
1032
Jesse Hall42a9eec2016-06-03 12:39:49 -07001033 ALOGV_IF(create_info->imageArrayLayers != 1,
Jesse Halldc225072016-05-30 22:40:14 -07001034 "swapchain imageArrayLayers=%u not supported",
Jesse Hall715b86a2016-01-16 16:34:29 -08001035 create_info->imageArrayLayers);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001036 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
Jesse Halldc225072016-05-30 22:40:14 -07001037 "swapchain preTransform=%#x not supported",
Jesse Hall55bc0972016-02-23 16:43:29 -08001038 create_info->preTransform);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001039 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
Chris Forbes980ad052017-01-18 16:55:07 +13001040 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
Chris Forbes1d5f68c2017-01-31 10:17:01 +13001041 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1042 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
Jesse Halldc225072016-05-30 22:40:14 -07001043 "swapchain presentMode=%u not supported",
Jesse Hall0ae0dce2016-02-09 22:13:34 -08001044 create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -07001045
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001046 Surface& surface = *SurfaceFromHandle(create_info->surface);
1047
Jesse Halldc225072016-05-30 22:40:14 -07001048 if (surface.swapchain_handle != create_info->oldSwapchain) {
Jesse Hall42a9eec2016-06-03 12:39:49 -07001049 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
Jesse Halldc225072016-05-30 22:40:14 -07001050 " because it already has active swapchain 0x%" PRIx64
1051 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
1052 reinterpret_cast<uint64_t>(create_info->surface),
1053 reinterpret_cast<uint64_t>(surface.swapchain_handle),
1054 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1055 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
1056 }
1057 if (create_info->oldSwapchain != VK_NULL_HANDLE)
1058 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
1059
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001060 // -- Reset the native window --
1061 // The native window might have been used previously, and had its properties
1062 // changed from defaults. That will affect the answer we get for queries
1063 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
1064 // attempt such queries.
1065
Jesse Halldc225072016-05-30 22:40:14 -07001066 // The native window only allows dequeueing all buffers before any have
1067 // been queued, since after that point at least one is assumed to be in
1068 // non-FREE state at any given time. Disconnecting and re-connecting
1069 // orphans the previous buffers, getting us back to the state where we can
1070 // dequeue all buffers.
Yiwei Zhang70a21962019-05-31 17:26:52 -07001071 //
1072 // TODO(http://b/134186185) recycle swapchain images more efficiently
Jesse Halldc225072016-05-30 22:40:14 -07001073 err = native_window_api_disconnect(surface.window.get(),
1074 NATIVE_WINDOW_API_EGL);
1075 ALOGW_IF(err != 0, "native_window_api_disconnect failed: %s (%d)",
1076 strerror(-err), err);
1077 err =
1078 native_window_api_connect(surface.window.get(), NATIVE_WINDOW_API_EGL);
1079 ALOGW_IF(err != 0, "native_window_api_connect failed: %s (%d)",
1080 strerror(-err), err);
1081
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001082 err = native_window_set_buffer_count(surface.window.get(), 0);
1083 if (err != 0) {
1084 ALOGE("native_window_set_buffer_count(0) failed: %s (%d)",
1085 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001086 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001087 }
1088
Hrishikesh Manohar9b7e4532017-01-10 17:52:11 +05301089 int swap_interval =
1090 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
1091 err = surface.window->setSwapInterval(surface.window.get(), swap_interval);
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001092 if (err != 0) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001093 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
1094 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001095 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001096 }
1097
Chris Forbesb8042d22017-01-18 18:07:05 +13001098 err = native_window_set_shared_buffer_mode(surface.window.get(), false);
1099 if (err != 0) {
1100 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
1101 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001102 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001103 }
1104
1105 err = native_window_set_auto_refresh(surface.window.get(), false);
1106 if (err != 0) {
1107 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
1108 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001109 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbesb8042d22017-01-18 18:07:05 +13001110 }
1111
Jesse Halld7b994a2015-09-07 14:17:37 -07001112 // -- Configure the native window --
Jesse Halld7b994a2015-09-07 14:17:37 -07001113
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001114 const auto& dispatch = GetData(device).driver;
Jesse Hall70f93352015-11-04 09:41:31 -08001115
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001116 err = native_window_set_buffers_format(surface.window.get(),
1117 native_pixel_format);
Jesse Hall517274a2016-02-10 00:07:18 -08001118 if (err != 0) {
Jesse Hall517274a2016-02-10 00:07:18 -08001119 ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001120 native_pixel_format, strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001121 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001122 }
1123 err = native_window_set_buffers_data_space(surface.window.get(),
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001124 native_dataspace);
Jesse Hall517274a2016-02-10 00:07:18 -08001125 if (err != 0) {
Jesse Hall517274a2016-02-10 00:07:18 -08001126 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -07001127 native_dataspace, strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001128 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall517274a2016-02-10 00:07:18 -08001129 }
1130
Jesse Hall3dd678a2016-01-08 21:52:01 -08001131 err = native_window_set_buffers_dimensions(
1132 surface.window.get(), static_cast<int>(create_info->imageExtent.width),
1133 static_cast<int>(create_info->imageExtent.height));
Jesse Halld7b994a2015-09-07 14:17:37 -07001134 if (err != 0) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001135 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
1136 create_info->imageExtent.width, create_info->imageExtent.height,
1137 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001138 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001139 }
1140
Jesse Hall178b6962016-02-24 15:39:50 -08001141 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
1142 // applied during rendering. native_window_set_transform() expects the
1143 // inverse: the transform the app is requesting that the compositor perform
1144 // during composition. With native windows, pre-transform works by rendering
1145 // with the same transform the compositor is applying (as in Vulkan), but
1146 // then requesting the inverse transform, so that when the compositor does
1147 // it's job the two transforms cancel each other out and the compositor ends
1148 // up applying an identity transform to the app's buffer.
1149 err = native_window_set_buffers_transform(
1150 surface.window.get(),
1151 InvertTransformToNative(create_info->preTransform));
1152 if (err != 0) {
Jesse Hall178b6962016-02-24 15:39:50 -08001153 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
1154 InvertTransformToNative(create_info->preTransform),
1155 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001156 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall178b6962016-02-24 15:39:50 -08001157 }
1158
Jesse Hallf64ca122015-11-03 16:11:10 -08001159 err = native_window_set_scaling_mode(
Jesse Hall1356b0d2015-11-23 17:24:58 -08001160 surface.window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
Jesse Hallf64ca122015-11-03 16:11:10 -08001161 if (err != 0) {
Jesse Hallf64ca122015-11-03 16:11:10 -08001162 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
1163 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001164 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hallf64ca122015-11-03 16:11:10 -08001165 }
1166
Chris Forbes97ef4612017-03-30 19:37:50 +13001167 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
1168 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1169 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1170 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
1171 err = native_window_set_shared_buffer_mode(surface.window.get(), true);
1172 if (err != 0) {
1173 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
1174 return VK_ERROR_SURFACE_LOST_KHR;
1175 }
1176 }
1177
1178 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1179 err = native_window_set_auto_refresh(surface.window.get(), true);
1180 if (err != 0) {
1181 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
1182 return VK_ERROR_SURFACE_LOST_KHR;
1183 }
1184 }
1185
Jesse Halle6080bf2016-02-28 20:58:50 -08001186 int query_value;
1187 err = surface.window->query(surface.window.get(),
1188 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
1189 &query_value);
1190 if (err != 0 || query_value < 0) {
Jesse Halle6080bf2016-02-28 20:58:50 -08001191 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
1192 query_value);
Mike Stroyan762c8132017-02-22 11:43:09 -07001193 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001194 }
Jesse Halle6080bf2016-02-28 20:58:50 -08001195 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
Jesse Halld7b994a2015-09-07 14:17:37 -07001196 uint32_t num_images =
Ian Elliotta3515f42019-05-15 14:11:33 -06001197 (swap_interval ? create_info->minImageCount
1198 : std::max(3u, create_info->minImageCount)) -
1199 1 + min_undequeued_buffers;
Chris Forbes2c8fc752017-03-17 11:28:32 +13001200
1201 // Lower layer insists that we have at least two buffers. This is wasteful
1202 // and we'd like to relax it in the shared case, but not all the pieces are
1203 // in place for that to work yet. Note we only lie to the lower layer-- we
1204 // don't want to give the app back a swapchain with extra images (which they
1205 // can't actually use!).
1206 err = native_window_set_buffer_count(surface.window.get(), std::max(2u, num_images));
Jesse Halld7b994a2015-09-07 14:17:37 -07001207 if (err != 0) {
Jesse Hall3d1c82a2016-04-22 15:28:29 -07001208 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
1209 strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001210 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001211 }
1212
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001213 int32_t legacy_usage = 0;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001214 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
Jesse Halld1abd742017-02-09 21:45:51 -08001215 uint64_t consumer_usage, producer_usage;
Yiwei Zhang533cea92019-06-03 18:43:24 -07001216 ATRACE_BEGIN("GetSwapchainGrallocUsage2ANDROID");
Courtney Goeltzenleuchter894780b2017-04-03 16:11:30 -06001217 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1218 device, create_info->imageFormat, create_info->imageUsage,
1219 swapchain_image_usage, &consumer_usage, &producer_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001220 ATRACE_END();
Chris Forbes8c47dc92017-01-12 11:13:58 +13001221 if (result != VK_SUCCESS) {
1222 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001223 return VK_ERROR_SURFACE_LOST_KHR;
Chris Forbes8c47dc92017-01-12 11:13:58 +13001224 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001225 legacy_usage =
Jesse Hall79927812017-03-23 11:03:23 -07001226 android_convertGralloc1To0Usage(producer_usage, consumer_usage);
Chris Forbes8c47dc92017-01-12 11:13:58 +13001227 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001228 ATRACE_BEGIN("GetSwapchainGrallocUsageANDROID");
Jesse Hall1f91d392015-12-11 16:28:44 -08001229 result = dispatch.GetSwapchainGrallocUsageANDROID(
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001230 device, create_info->imageFormat, create_info->imageUsage,
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001231 &legacy_usage);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001232 ATRACE_END();
Jesse Hall70f93352015-11-04 09:41:31 -08001233 if (result != VK_SUCCESS) {
1234 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
Mike Stroyan762c8132017-02-22 11:43:09 -07001235 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001236 }
Jesse Hall70f93352015-11-04 09:41:31 -08001237 }
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001238 uint64_t native_usage = static_cast<uint64_t>(legacy_usage);
1239
1240 bool createProtectedSwapchain = false;
1241 if (create_info->flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
1242 createProtectedSwapchain = true;
1243 native_usage |= BufferUsage::PROTECTED;
1244 }
1245 err = native_window_set_usage(surface.window.get(), native_usage);
Jesse Hall70f93352015-11-04 09:41:31 -08001246 if (err != 0) {
Jesse Hall70f93352015-11-04 09:41:31 -08001247 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001248 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Hall70f93352015-11-04 09:41:31 -08001249 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001250
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001251 int transform_hint;
1252 err = surface.window->query(surface.window.get(),
1253 NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
1254 if (err != 0) {
1255 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1256 strerror(-err), err);
1257 return VK_ERROR_SURFACE_LOST_KHR;
1258 }
1259
Jesse Halld7b994a2015-09-07 14:17:37 -07001260 // -- Allocate our Swapchain object --
1261 // After this point, we must deallocate the swapchain on error.
1262
Jesse Hall1f91d392015-12-11 16:28:44 -08001263 void* mem = allocator->pfnAllocation(allocator->pUserData,
1264 sizeof(Swapchain), alignof(Swapchain),
1265 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001266 if (!mem)
Jesse Halld7b994a2015-09-07 14:17:37 -07001267 return VK_ERROR_OUT_OF_HOST_MEMORY;
silence_dogood73597592019-05-23 16:57:37 -07001268 Swapchain* swapchain = new (mem)
1269 Swapchain(surface, num_images, create_info->presentMode,
1270 TranslateVulkanToNativeTransform(create_info->preTransform));
Jesse Halld7b994a2015-09-07 14:17:37 -07001271 // -- Dequeue all buffers and create a VkImage for each --
1272 // Any failures during or after this must cancel the dequeued buffers.
1273
Chris Forbesb56287a2017-01-12 14:28:58 +13001274 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1275#pragma clang diagnostic push
1276#pragma clang diagnostic ignored "-Wold-style-cast"
1277 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1278#pragma clang diagnostic pop
1279 .pNext = nullptr,
1280 .usage = swapchain_image_usage,
1281 };
Jesse Halld7b994a2015-09-07 14:17:37 -07001282 VkNativeBufferANDROID image_native_buffer = {
Jesse Halld7b994a2015-09-07 14:17:37 -07001283#pragma clang diagnostic push
1284#pragma clang diagnostic ignored "-Wold-style-cast"
1285 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1286#pragma clang diagnostic pop
Chris Forbesb56287a2017-01-12 14:28:58 +13001287 .pNext = &swapchain_image_create,
Jesse Halld7b994a2015-09-07 14:17:37 -07001288 };
1289 VkImageCreateInfo image_create = {
1290 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1291 .pNext = &image_native_buffer,
Nick Desaulnierse745a3e2019-10-18 10:38:45 -07001292 .flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
Jesse Halld7b994a2015-09-07 14:17:37 -07001293 .imageType = VK_IMAGE_TYPE_2D,
Jesse Hall517274a2016-02-10 00:07:18 -08001294 .format = create_info->imageFormat,
Jesse Halld7b994a2015-09-07 14:17:37 -07001295 .extent = {0, 0, 1},
1296 .mipLevels = 1,
Jesse Halla15a4bf2015-11-19 22:48:02 -08001297 .arrayLayers = 1,
Jesse Hall091ed9e2015-11-30 00:55:29 -08001298 .samples = VK_SAMPLE_COUNT_1_BIT,
Jesse Halld7b994a2015-09-07 14:17:37 -07001299 .tiling = VK_IMAGE_TILING_OPTIMAL,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001300 .usage = create_info->imageUsage,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001301 .sharingMode = create_info->imageSharingMode,
Jesse Hall03b6fe12015-11-24 12:44:21 -08001302 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
Jesse Halld7b994a2015-09-07 14:17:37 -07001303 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1304 };
1305
Jesse Halld7b994a2015-09-07 14:17:37 -07001306 for (uint32_t i = 0; i < num_images; i++) {
1307 Swapchain::Image& img = swapchain->images[i];
1308
1309 ANativeWindowBuffer* buffer;
Jesse Hall1356b0d2015-11-23 17:24:58 -08001310 err = surface.window->dequeueBuffer(surface.window.get(), &buffer,
1311 &img.dequeue_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001312 if (err != 0) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001313 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
Yiwei Zhang702beb42019-11-29 17:59:55 -08001314 switch (-err) {
1315 case ENOMEM:
1316 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
1317 break;
1318 default:
1319 result = VK_ERROR_SURFACE_LOST_KHR;
1320 break;
1321 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001322 break;
1323 }
Chia-I Wue8e689f2016-04-18 08:21:31 +08001324 img.buffer = buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -07001325 img.dequeued = true;
1326
1327 image_create.extent =
Jesse Hall3dd678a2016-01-08 21:52:01 -08001328 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1329 static_cast<uint32_t>(img.buffer->height),
1330 1};
Jesse Halld7b994a2015-09-07 14:17:37 -07001331 image_native_buffer.handle = img.buffer->handle;
1332 image_native_buffer.stride = img.buffer->stride;
1333 image_native_buffer.format = img.buffer->format;
Mathias Agopiancb496ac2017-05-22 14:21:00 -07001334 image_native_buffer.usage = int(img.buffer->usage);
Chris Forbes8e0c3f52017-05-19 14:47:29 -07001335 android_convertGralloc0To1Usage(int(img.buffer->usage),
1336 &image_native_buffer.usage2.producer,
1337 &image_native_buffer.usage2.consumer);
Jesse Halld7b994a2015-09-07 14:17:37 -07001338
Yiwei Zhang533cea92019-06-03 18:43:24 -07001339 ATRACE_BEGIN("CreateImage");
Jesse Hall03b6fe12015-11-24 12:44:21 -08001340 result =
Jesse Hall1f91d392015-12-11 16:28:44 -08001341 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001342 ATRACE_END();
Jesse Halld7b994a2015-09-07 14:17:37 -07001343 if (result != VK_SUCCESS) {
1344 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1345 break;
1346 }
1347 }
1348
1349 // -- Cancel all buffers, returning them to the queue --
1350 // If an error occurred before, also destroy the VkImage and release the
1351 // buffer reference. Otherwise, we retain a strong reference to the buffer.
Chris Forbes31b85c22018-05-29 15:03:28 -07001352 for (uint32_t i = 0; i < num_images; i++) {
1353 Swapchain::Image& img = swapchain->images[i];
1354 if (img.dequeued) {
1355 if (!swapchain->shared) {
Chris Forbese0ced032017-03-30 19:44:15 +13001356 surface.window->cancelBuffer(surface.window.get(), img.buffer.get(),
1357 img.dequeue_fence);
1358 img.dequeue_fence = -1;
1359 img.dequeued = false;
1360 }
Chris Forbes31b85c22018-05-29 15:03:28 -07001361 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001362 }
1363
1364 if (result != VK_SUCCESS) {
Yiwei Zhang533cea92019-06-03 18:43:24 -07001365 DestroySwapchainInternal(device, HandleFromSwapchain(swapchain),
1366 allocator);
Jesse Halld7b994a2015-09-07 14:17:37 -07001367 return result;
1368 }
1369
Yiwei Zhang69395cd2019-07-03 16:55:39 -07001370 if (transform_hint != swapchain->pre_transform) {
1371 // Log that the app is not doing pre-rotation.
1372 android::GraphicsEnv::getInstance().setTargetStats(
1373 android::GpuStatsInfo::Stats::FALSE_PREROTATION);
1374 }
1375
Jesse Halldc225072016-05-30 22:40:14 -07001376 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1377 *swapchain_handle = surface.swapchain_handle;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001378 return VK_SUCCESS;
1379}
1380
Jesse Halle1b12782015-11-30 11:27:32 -08001381VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001382void DestroySwapchainKHR(VkDevice device,
1383 VkSwapchainKHR swapchain_handle,
1384 const VkAllocationCallbacks* allocator) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001385 ATRACE_CALL();
1386
Yiwei Zhang533cea92019-06-03 18:43:24 -07001387 DestroySwapchainInternal(device, swapchain_handle, allocator);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001388}
1389
Jesse Halle1b12782015-11-30 11:27:32 -08001390VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001391VkResult GetSwapchainImagesKHR(VkDevice,
1392 VkSwapchainKHR swapchain_handle,
1393 uint32_t* count,
1394 VkImage* images) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001395 ATRACE_CALL();
1396
Jesse Halld7b994a2015-09-07 14:17:37 -07001397 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Halldc225072016-05-30 22:40:14 -07001398 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1399 "getting images for non-active swapchain 0x%" PRIx64
1400 "; only dequeued image handles are valid",
1401 reinterpret_cast<uint64_t>(swapchain_handle));
Jesse Halld7b994a2015-09-07 14:17:37 -07001402 VkResult result = VK_SUCCESS;
1403 if (images) {
1404 uint32_t n = swapchain.num_images;
1405 if (*count < swapchain.num_images) {
1406 n = *count;
1407 result = VK_INCOMPLETE;
1408 }
1409 for (uint32_t i = 0; i < n; i++)
1410 images[i] = swapchain.images[i].image;
Jesse Hall7331e222016-09-15 21:26:01 -07001411 *count = n;
1412 } else {
1413 *count = swapchain.num_images;
Jesse Halld7b994a2015-09-07 14:17:37 -07001414 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001415 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001416}
1417
Jesse Halle1b12782015-11-30 11:27:32 -08001418VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001419VkResult AcquireNextImageKHR(VkDevice device,
1420 VkSwapchainKHR swapchain_handle,
1421 uint64_t timeout,
1422 VkSemaphore semaphore,
1423 VkFence vk_fence,
1424 uint32_t* image_index) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001425 ATRACE_CALL();
1426
Jesse Halld7b994a2015-09-07 14:17:37 -07001427 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001428 ANativeWindow* window = swapchain.surface.window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -07001429 VkResult result;
1430 int err;
1431
Jesse Halldc225072016-05-30 22:40:14 -07001432 if (swapchain.surface.swapchain_handle != swapchain_handle)
1433 return VK_ERROR_OUT_OF_DATE_KHR;
1434
Jesse Halld7b994a2015-09-07 14:17:37 -07001435 ALOGW_IF(
1436 timeout != UINT64_MAX,
1437 "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");
1438
Chris Forbesc88409c2017-03-30 19:47:37 +13001439 if (swapchain.shared) {
1440 // In shared mode, we keep the buffer dequeued all the time, so we don't
1441 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1442 // the semaphore and fence passed to us will be signalled.
1443 *image_index = 0;
1444 result = GetData(device).driver.AcquireImageANDROID(
1445 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1446 return result;
1447 }
1448
Jesse Halld7b994a2015-09-07 14:17:37 -07001449 ANativeWindowBuffer* buffer;
Jesse Hall06193802015-12-03 16:12:51 -08001450 int fence_fd;
1451 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001452 if (err != 0) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001453 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
Mike Stroyan762c8132017-02-22 11:43:09 -07001454 return VK_ERROR_SURFACE_LOST_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001455 }
1456
1457 uint32_t idx;
1458 for (idx = 0; idx < swapchain.num_images; idx++) {
1459 if (swapchain.images[idx].buffer.get() == buffer) {
1460 swapchain.images[idx].dequeued = true;
Jesse Hall06193802015-12-03 16:12:51 -08001461 swapchain.images[idx].dequeue_fence = fence_fd;
Jesse Halld7b994a2015-09-07 14:17:37 -07001462 break;
1463 }
1464 }
1465 if (idx == swapchain.num_images) {
1466 ALOGE("dequeueBuffer returned unrecognized buffer");
Jesse Hall06193802015-12-03 16:12:51 -08001467 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001468 return VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001469 }
1470
1471 int fence_clone = -1;
Jesse Hall06193802015-12-03 16:12:51 -08001472 if (fence_fd != -1) {
1473 fence_clone = dup(fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001474 if (fence_clone == -1) {
1475 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1476 strerror(errno), errno);
Jesse Hall06193802015-12-03 16:12:51 -08001477 sync_wait(fence_fd, -1 /* forever */);
Jesse Halld7b994a2015-09-07 14:17:37 -07001478 }
1479 }
1480
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001481 result = GetData(device).driver.AcquireImageANDROID(
Jesse Hall1f91d392015-12-11 16:28:44 -08001482 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001483 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001484 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1485 // even if the call fails. We could close it ourselves on failure, but
1486 // that would create a race condition if the driver closes it on a
1487 // failure path: some other thread might create an fd with the same
1488 // number between the time the driver closes it and the time we close
1489 // it. We must assume one of: the driver *always* closes it even on
1490 // failure, or *never* closes it on failure.
Jesse Hall06193802015-12-03 16:12:51 -08001491 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001492 swapchain.images[idx].dequeued = false;
1493 swapchain.images[idx].dequeue_fence = -1;
1494 return result;
1495 }
1496
1497 *image_index = idx;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001498 return VK_SUCCESS;
1499}
1500
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001501VKAPI_ATTR
1502VkResult AcquireNextImage2KHR(VkDevice device,
1503 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1504 uint32_t* pImageIndex) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001505 ATRACE_CALL();
1506
Daniel Kochf25f5bb2017-10-05 00:26:58 -04001507 return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
1508 pAcquireInfo->timeout, pAcquireInfo->semaphore,
1509 pAcquireInfo->fence, pImageIndex);
1510}
1511
Jesse Halldc225072016-05-30 22:40:14 -07001512static VkResult WorstPresentResult(VkResult a, VkResult b) {
1513 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1514 // (in spec version 1.0.14).
1515 static const VkResult kWorstToBest[] = {
1516 VK_ERROR_DEVICE_LOST,
1517 VK_ERROR_SURFACE_LOST_KHR,
1518 VK_ERROR_OUT_OF_DATE_KHR,
1519 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1520 VK_ERROR_OUT_OF_HOST_MEMORY,
1521 VK_SUBOPTIMAL_KHR,
1522 };
1523 for (auto result : kWorstToBest) {
1524 if (a == result || b == result)
1525 return result;
1526 }
1527 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1528 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1529 return a != VK_SUCCESS ? a : b;
1530}
1531
Jesse Halle1b12782015-11-30 11:27:32 -08001532VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001533VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001534 ATRACE_CALL();
1535
Jesse Halld7b994a2015-09-07 14:17:37 -07001536 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1537 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1538 present_info->sType);
Jesse Halld7b994a2015-09-07 14:17:37 -07001539
Jesse Halldc225072016-05-30 22:40:14 -07001540 VkDevice device = GetData(queue).driver_device;
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001541 const auto& dispatch = GetData(queue).driver;
Jesse Halld7b994a2015-09-07 14:17:37 -07001542 VkResult final_result = VK_SUCCESS;
Jesse Halldc225072016-05-30 22:40:14 -07001543
Ian Elliottcb351132016-12-13 10:30:40 -07001544 // Look at the pNext chain for supported extension structs:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001545 const VkPresentRegionsKHR* present_regions = nullptr;
1546 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001547 const VkPresentRegionsKHR* next =
1548 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1549 while (next) {
1550 switch (next->sType) {
1551 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1552 present_regions = next;
1553 break;
Ian Elliott14866bb2017-01-20 09:15:48 -07001554 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001555 present_times =
1556 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1557 break;
Ian Elliottcb351132016-12-13 10:30:40 -07001558 default:
1559 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1560 next->sType);
1561 break;
1562 }
1563 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1564 }
1565 ALOGV_IF(
1566 present_regions &&
1567 present_regions->swapchainCount != present_info->swapchainCount,
1568 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001569 ALOGV_IF(present_times &&
1570 present_times->swapchainCount != present_info->swapchainCount,
1571 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1572 "VkPresentInfo::swapchainCount");
Ian Elliottcb351132016-12-13 10:30:40 -07001573 const VkPresentRegionKHR* regions =
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001574 (present_regions) ? present_regions->pRegions : nullptr;
1575 const VkPresentTimeGOOGLE* times =
1576 (present_times) ? present_times->pTimes : nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001577 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001578 android_native_rect_t* rects = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001579 uint32_t nrects = 0;
1580
Jesse Halld7b994a2015-09-07 14:17:37 -07001581 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1582 Swapchain& swapchain =
Jesse Hall03b6fe12015-11-24 12:44:21 -08001583 *SwapchainFromHandle(present_info->pSwapchains[sc]);
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001584 uint32_t image_idx = present_info->pImageIndices[sc];
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001585 Swapchain::Image& img = swapchain.images[image_idx];
Ian Elliottffedb652017-02-14 10:58:30 -07001586 const VkPresentRegionKHR* region =
1587 (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001588 const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
Jesse Halldc225072016-05-30 22:40:14 -07001589 VkResult swapchain_result = VK_SUCCESS;
Jesse Halld7b994a2015-09-07 14:17:37 -07001590 VkResult result;
1591 int err;
1592
Jesse Halld7b994a2015-09-07 14:17:37 -07001593 int fence = -1;
Jesse Hall275d76c2016-01-08 22:39:16 -08001594 result = dispatch.QueueSignalReleaseImageANDROID(
1595 queue, present_info->waitSemaphoreCount,
1596 present_info->pWaitSemaphores, img.image, &fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001597 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001598 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
Jesse Halldc225072016-05-30 22:40:14 -07001599 swapchain_result = result;
Jesse Halld7b994a2015-09-07 14:17:37 -07001600 }
1601
Jesse Halldc225072016-05-30 22:40:14 -07001602 if (swapchain.surface.swapchain_handle ==
1603 present_info->pSwapchains[sc]) {
1604 ANativeWindow* window = swapchain.surface.window.get();
1605 if (swapchain_result == VK_SUCCESS) {
Ian Elliottcb351132016-12-13 10:30:40 -07001606 if (region) {
1607 // Process the incremental-present hint for this swapchain:
1608 uint32_t rcount = region->rectangleCount;
1609 if (rcount > nrects) {
1610 android_native_rect_t* new_rects =
1611 static_cast<android_native_rect_t*>(
1612 allocator->pfnReallocation(
1613 allocator->pUserData, rects,
1614 sizeof(android_native_rect_t) * rcount,
1615 alignof(android_native_rect_t),
1616 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1617 if (new_rects) {
1618 rects = new_rects;
1619 nrects = rcount;
1620 } else {
1621 rcount = 0; // Ignore the hint for this swapchain
1622 }
1623 }
1624 for (uint32_t r = 0; r < rcount; ++r) {
1625 if (region->pRectangles[r].layer > 0) {
1626 ALOGV(
1627 "vkQueuePresentKHR ignoring invalid layer "
1628 "(%u); using layer 0 instead",
1629 region->pRectangles[r].layer);
1630 }
1631 int x = region->pRectangles[r].offset.x;
1632 int y = region->pRectangles[r].offset.y;
1633 int width = static_cast<int>(
1634 region->pRectangles[r].extent.width);
1635 int height = static_cast<int>(
1636 region->pRectangles[r].extent.height);
1637 android_native_rect_t* cur_rect = &rects[r];
1638 cur_rect->left = x;
1639 cur_rect->top = y + height;
1640 cur_rect->right = x + width;
1641 cur_rect->bottom = y;
1642 }
1643 native_window_set_surface_damage(window, rects, rcount);
1644 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001645 if (time) {
1646 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001647 ALOGV(
1648 "Calling "
1649 "native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001650 native_window_enable_frame_timestamps(window, true);
1651 swapchain.frame_timestamps_enabled = true;
1652 }
Brian Anderson1049d1d2016-12-16 17:25:57 -08001653
1654 // Record the nativeFrameId so it can be later correlated to
1655 // this present.
1656 uint64_t nativeFrameId = 0;
1657 err = native_window_get_next_frame_id(
1658 window, &nativeFrameId);
1659 if (err != android::NO_ERROR) {
1660 ALOGE("Failed to get next native frame ID.");
1661 }
1662
1663 // Add a new timing record with the user's presentID and
1664 // the nativeFrameId.
Yiwei Zhang5e862202019-06-21 14:59:16 -07001665 swapchain.timing.emplace_back(time, nativeFrameId);
Brian Anderson1049d1d2016-12-16 17:25:57 -08001666 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
Yiwei Zhang5e862202019-06-21 14:59:16 -07001667 swapchain.timing.erase(swapchain.timing.begin());
Ian Elliott8a977262017-01-19 09:05:58 -07001668 }
1669 if (time->desiredPresentTime) {
1670 // Set the desiredPresentTime:
1671 ALOGV(
1672 "Calling "
1673 "native_window_set_buffers_timestamp(%" PRId64 ")",
1674 time->desiredPresentTime);
1675 native_window_set_buffers_timestamp(
1676 window,
1677 static_cast<int64_t>(time->desiredPresentTime));
1678 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001679 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001680
Jesse Halldc225072016-05-30 22:40:14 -07001681 err = window->queueBuffer(window, img.buffer.get(), fence);
1682 // queueBuffer always closes fence, even on error
1683 if (err != 0) {
Jesse Halldc225072016-05-30 22:40:14 -07001684 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1685 swapchain_result = WorstPresentResult(
1686 swapchain_result, VK_ERROR_OUT_OF_DATE_KHR);
Yiwei Zhang0b468472019-06-03 18:57:19 -07001687 } else {
1688 if (img.dequeue_fence >= 0) {
1689 close(img.dequeue_fence);
1690 img.dequeue_fence = -1;
1691 }
1692 img.dequeued = false;
Jesse Halldc225072016-05-30 22:40:14 -07001693 }
Chris Forbesfca0f292017-03-30 19:48:39 +13001694
1695 // If the swapchain is in shared mode, immediately dequeue the
1696 // buffer so it can be presented again without an intervening
1697 // call to AcquireNextImageKHR. We expect to get the same buffer
1698 // back from every call to dequeueBuffer in this mode.
1699 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
1700 ANativeWindowBuffer* buffer;
1701 int fence_fd;
1702 err = window->dequeueBuffer(window, &buffer, &fence_fd);
1703 if (err != 0) {
1704 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1705 swapchain_result = WorstPresentResult(swapchain_result,
1706 VK_ERROR_SURFACE_LOST_KHR);
1707 }
1708 else if (img.buffer != buffer) {
1709 ALOGE("got wrong image back for shared swapchain");
1710 swapchain_result = WorstPresentResult(swapchain_result,
1711 VK_ERROR_SURFACE_LOST_KHR);
1712 }
1713 else {
1714 img.dequeue_fence = fence_fd;
1715 img.dequeued = true;
1716 }
1717 }
Jesse Halldc225072016-05-30 22:40:14 -07001718 }
1719 if (swapchain_result != VK_SUCCESS) {
Jesse Halldc225072016-05-30 22:40:14 -07001720 OrphanSwapchain(device, &swapchain);
1721 }
silence_dogood73597592019-05-23 16:57:37 -07001722 int window_transform_hint;
1723 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
1724 &window_transform_hint);
1725 if (err != 0) {
1726 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1727 strerror(-err), err);
1728 swapchain_result = WorstPresentResult(
1729 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
1730 }
1731 if (swapchain.pre_transform != window_transform_hint) {
1732 swapchain_result =
1733 WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
1734 }
Jesse Halldc225072016-05-30 22:40:14 -07001735 } else {
1736 ReleaseSwapchainImage(device, nullptr, fence, img);
1737 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001738 }
1739
Jesse Halla9e57032015-11-30 01:03:10 -08001740 if (present_info->pResults)
Jesse Halldc225072016-05-30 22:40:14 -07001741 present_info->pResults[sc] = swapchain_result;
1742
1743 if (swapchain_result != final_result)
1744 final_result = WorstPresentResult(final_result, swapchain_result);
Jesse Halld7b994a2015-09-07 14:17:37 -07001745 }
Ian Elliottcb351132016-12-13 10:30:40 -07001746 if (rects) {
1747 allocator->pfnFree(allocator->pUserData, rects);
1748 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001749
1750 return final_result;
1751}
Jesse Hallb1352bc2015-09-04 16:12:33 -07001752
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001753VKAPI_ATTR
1754VkResult GetRefreshCycleDurationGOOGLE(
1755 VkDevice,
Ian Elliott62c48c92017-01-20 13:13:20 -07001756 VkSwapchainKHR swapchain_handle,
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001757 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001758 ATRACE_CALL();
1759
Ian Elliott62c48c92017-01-20 13:13:20 -07001760 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001761 VkResult result = VK_SUCCESS;
1762
Ian Elliott3568bfe2019-05-03 15:54:46 -06001763 pDisplayTimingProperties->refreshDuration = swapchain.get_refresh_duration();
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001764
1765 return result;
1766}
1767
1768VKAPI_ATTR
1769VkResult GetPastPresentationTimingGOOGLE(
1770 VkDevice,
1771 VkSwapchainKHR swapchain_handle,
1772 uint32_t* count,
1773 VkPastPresentationTimingGOOGLE* timings) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001774 ATRACE_CALL();
1775
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001776 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001777 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1778 return VK_ERROR_OUT_OF_DATE_KHR;
1779 }
1780
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001781 ANativeWindow* window = swapchain.surface.window.get();
1782 VkResult result = VK_SUCCESS;
1783
1784 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001785 ALOGV("Calling native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001786 native_window_enable_frame_timestamps(window, true);
1787 swapchain.frame_timestamps_enabled = true;
1788 }
1789
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001790 if (timings) {
Yiwei Zhang9d187832019-07-22 15:15:47 -07001791 // Get the latest ready timing count before copying, since the copied
1792 // timing info will be erased in copy_ready_timings function.
1793 uint32_t n = get_num_ready_timings(swapchain);
Ian Elliott8a977262017-01-19 09:05:58 -07001794 copy_ready_timings(swapchain, count, timings);
Yiwei Zhang9d187832019-07-22 15:15:47 -07001795 // Check the *count here against the recorded ready timing count, since
1796 // *count can be overwritten per spec describes.
1797 if (*count < n) {
1798 result = VK_INCOMPLETE;
1799 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001800 } else {
Ian Elliott8a977262017-01-19 09:05:58 -07001801 *count = get_num_ready_timings(swapchain);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001802 }
1803
1804 return result;
1805}
1806
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001807VKAPI_ATTR
1808VkResult GetSwapchainStatusKHR(
1809 VkDevice,
Chris Forbes4e18ba82017-01-20 12:50:17 +13001810 VkSwapchainKHR swapchain_handle) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001811 ATRACE_CALL();
1812
Chris Forbes4e18ba82017-01-20 12:50:17 +13001813 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001814 VkResult result = VK_SUCCESS;
1815
Chris Forbes4e18ba82017-01-20 12:50:17 +13001816 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1817 return VK_ERROR_OUT_OF_DATE_KHR;
1818 }
1819
Yiwei Zhanga885c062019-10-24 12:07:57 -07001820 // TODO(b/143296009): Implement this function properly
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001821
1822 return result;
1823}
1824
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001825VKAPI_ATTR void SetHdrMetadataEXT(
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001826 VkDevice,
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001827 uint32_t swapchainCount,
1828 const VkSwapchainKHR* pSwapchains,
1829 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
Yiwei Zhangfdd0c2a2019-01-30 20:16:37 -08001830 ATRACE_CALL();
Courtney Goeltzenleuchter7671d462018-01-24 11:51:01 -08001831
1832 for (uint32_t idx = 0; idx < swapchainCount; idx++) {
1833 Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);
1834 if (!swapchain)
1835 continue;
1836
1837 if (swapchain->surface.swapchain_handle != pSwapchains[idx]) continue;
1838
1839 ANativeWindow* window = swapchain->surface.window.get();
1840
1841 VkHdrMetadataEXT vulkanMetadata = pHdrMetadataEXTs[idx];
1842 const android_smpte2086_metadata smpteMetdata = {
1843 {vulkanMetadata.displayPrimaryRed.x,
1844 vulkanMetadata.displayPrimaryRed.y},
1845 {vulkanMetadata.displayPrimaryGreen.x,
1846 vulkanMetadata.displayPrimaryGreen.y},
1847 {vulkanMetadata.displayPrimaryBlue.x,
1848 vulkanMetadata.displayPrimaryBlue.y},
1849 {vulkanMetadata.whitePoint.x, vulkanMetadata.whitePoint.y},
1850 vulkanMetadata.maxLuminance,
1851 vulkanMetadata.minLuminance};
1852 native_window_set_buffers_smpte2086_metadata(window, &smpteMetdata);
1853
1854 const android_cta861_3_metadata cta8613Metadata = {
1855 vulkanMetadata.maxContentLightLevel,
1856 vulkanMetadata.maxFrameAverageLightLevel};
1857 native_window_set_buffers_cta861_3_metadata(window, &cta8613Metadata);
1858 }
1859
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001860 return;
1861}
1862
Yiwei Zhang0f475222019-04-11 19:38:00 -07001863static void InterceptBindImageMemory2(
1864 uint32_t bind_info_count,
1865 const VkBindImageMemoryInfo* bind_infos,
1866 std::vector<VkNativeBufferANDROID>* out_native_buffers,
1867 std::vector<VkBindImageMemoryInfo>* out_bind_infos) {
1868 out_native_buffers->clear();
1869 out_bind_infos->clear();
1870
1871 if (!bind_info_count)
1872 return;
1873
1874 std::unordered_set<uint32_t> intercepted_indexes;
1875
1876 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1877 auto info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1878 bind_infos[idx].pNext);
1879 while (info &&
1880 info->sType !=
1881 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR) {
1882 info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1883 info->pNext);
1884 }
1885
1886 if (!info)
1887 continue;
1888
1889 ALOG_ASSERT(info->swapchain != VK_NULL_HANDLE,
1890 "swapchain handle must not be NULL");
1891 const Swapchain* swapchain = SwapchainFromHandle(info->swapchain);
1892 ALOG_ASSERT(
1893 info->imageIndex < swapchain->num_images,
1894 "imageIndex must be less than the number of images in swapchain");
1895
1896 ANativeWindowBuffer* buffer =
1897 swapchain->images[info->imageIndex].buffer.get();
1898 VkNativeBufferANDROID native_buffer = {
1899#pragma clang diagnostic push
1900#pragma clang diagnostic ignored "-Wold-style-cast"
1901 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1902#pragma clang diagnostic pop
1903 .pNext = bind_infos[idx].pNext,
1904 .handle = buffer->handle,
1905 .stride = buffer->stride,
1906 .format = buffer->format,
1907 .usage = int(buffer->usage),
1908 };
1909 // Reserve enough space to avoid letting re-allocation invalidate the
1910 // addresses of the elements inside.
1911 out_native_buffers->reserve(bind_info_count);
1912 out_native_buffers->emplace_back(native_buffer);
1913
1914 // Reserve the space now since we know how much is needed now.
1915 out_bind_infos->reserve(bind_info_count);
1916 out_bind_infos->emplace_back(bind_infos[idx]);
1917 out_bind_infos->back().pNext = &out_native_buffers->back();
1918
1919 intercepted_indexes.insert(idx);
1920 }
1921
1922 if (intercepted_indexes.empty())
1923 return;
1924
1925 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1926 if (intercepted_indexes.count(idx))
1927 continue;
1928 out_bind_infos->emplace_back(bind_infos[idx]);
1929 }
1930}
1931
Yiwei Zhang23143102019-04-10 18:24:05 -07001932VKAPI_ATTR
1933VkResult BindImageMemory2(VkDevice device,
1934 uint32_t bindInfoCount,
1935 const VkBindImageMemoryInfo* pBindInfos) {
1936 ATRACE_CALL();
1937
Yiwei Zhang0f475222019-04-11 19:38:00 -07001938 // out_native_buffers is for maintaining the lifecycle of the constructed
1939 // VkNativeBufferANDROID objects inside InterceptBindImageMemory2.
1940 std::vector<VkNativeBufferANDROID> out_native_buffers;
1941 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1942 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1943 &out_bind_infos);
1944 return GetData(device).driver.BindImageMemory2(
1945 device, bindInfoCount,
1946 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07001947}
1948
1949VKAPI_ATTR
1950VkResult BindImageMemory2KHR(VkDevice device,
1951 uint32_t bindInfoCount,
1952 const VkBindImageMemoryInfo* pBindInfos) {
1953 ATRACE_CALL();
1954
Yiwei Zhang0f475222019-04-11 19:38:00 -07001955 std::vector<VkNativeBufferANDROID> out_native_buffers;
1956 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1957 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1958 &out_bind_infos);
1959 return GetData(device).driver.BindImageMemory2KHR(
1960 device, bindInfoCount,
1961 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
Yiwei Zhang23143102019-04-10 18:24:05 -07001962}
1963
Chia-I Wu62262232016-03-26 07:06:44 +08001964} // namespace driver
Jesse Hallb1352bc2015-09-04 16:12:33 -07001965} // namespace vulkan