1 /*
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
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19 #include <android/hardware/graphics/common/1.0/types.h>
20 #include <grallocusage/GrallocUsageConversion.h>
21 #include <graphicsenv/GraphicsEnv.h>
22 #include <log/log.h>
23 #include <sync/sync.h>
24 #include <system/window.h>
25 #include <ui/BufferQueueDefs.h>
26 #include <utils/StrongPointer.h>
27 #include <utils/Timers.h>
28 #include <utils/Trace.h>
29
30 #include <algorithm>
31 #include <unordered_set>
32 #include <vector>
33
34 #include "driver.h"
35
36 using android::hardware::graphics::common::V1_0::BufferUsage;
37
38 namespace vulkan {
39 namespace driver {
40
41 namespace {
42
43 const VkSurfaceTransformFlagsKHR kSupportedTransforms =
44 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
45 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
46 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
47 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
48 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
49 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
50 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
51 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
52 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
53
TranslateNativeToVulkanTransform(int native)54 VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
55 // Native and Vulkan transforms are isomorphic, but are represented
56 // differently. Vulkan transforms are built up of an optional horizontal
57 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
58 // transforms are built up from a horizontal flip, vertical flip, and
59 // 90-degree rotation, all optional but always in that order.
60
61 switch (native) {
62 case 0:
63 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
64 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
65 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
66 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
67 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
68 case NATIVE_WINDOW_TRANSFORM_ROT_180:
69 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
70 case NATIVE_WINDOW_TRANSFORM_ROT_90:
71 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
72 case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
73 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
74 case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
75 return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
76 case NATIVE_WINDOW_TRANSFORM_ROT_270:
77 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
78 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
79 default:
80 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
81 }
82 }
83
TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform)84 int TranslateVulkanToNativeTransform(VkSurfaceTransformFlagBitsKHR transform) {
85 switch (transform) {
86 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
87 return NATIVE_WINDOW_TRANSFORM_ROT_90;
88 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
89 return NATIVE_WINDOW_TRANSFORM_ROT_180;
90 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
91 return NATIVE_WINDOW_TRANSFORM_ROT_270;
92 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
93 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
94 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
95 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
96 NATIVE_WINDOW_TRANSFORM_ROT_90;
97 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
98 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
99 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
100 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
101 NATIVE_WINDOW_TRANSFORM_ROT_90;
102 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
103 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
104 default:
105 return 0;
106 }
107 }
108
InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform)109 int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
110 switch (transform) {
111 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
112 return NATIVE_WINDOW_TRANSFORM_ROT_270;
113 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
114 return NATIVE_WINDOW_TRANSFORM_ROT_180;
115 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
116 return NATIVE_WINDOW_TRANSFORM_ROT_90;
117 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
118 return NATIVE_WINDOW_TRANSFORM_FLIP_H;
119 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
120 return NATIVE_WINDOW_TRANSFORM_FLIP_H |
121 NATIVE_WINDOW_TRANSFORM_ROT_90;
122 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
123 return NATIVE_WINDOW_TRANSFORM_FLIP_V;
124 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
125 return NATIVE_WINDOW_TRANSFORM_FLIP_V |
126 NATIVE_WINDOW_TRANSFORM_ROT_90;
127 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
128 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
129 default:
130 return 0;
131 }
132 }
133
134 class TimingInfo {
135 public:
TimingInfo(const VkPresentTimeGOOGLE * qp,uint64_t nativeFrameId)136 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
137 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
138 native_frame_id_(nativeFrameId) {}
ready() const139 bool ready() const {
140 return (timestamp_desired_present_time_ !=
141 NATIVE_WINDOW_TIMESTAMP_PENDING &&
142 timestamp_actual_present_time_ !=
143 NATIVE_WINDOW_TIMESTAMP_PENDING &&
144 timestamp_render_complete_time_ !=
145 NATIVE_WINDOW_TIMESTAMP_PENDING &&
146 timestamp_composition_latch_time_ !=
147 NATIVE_WINDOW_TIMESTAMP_PENDING);
148 }
calculate(int64_t rdur)149 void calculate(int64_t rdur) {
150 bool anyTimestampInvalid =
151 (timestamp_actual_present_time_ ==
152 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
153 (timestamp_render_complete_time_ ==
154 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
155 (timestamp_composition_latch_time_ ==
156 NATIVE_WINDOW_TIMESTAMP_INVALID);
157 if (anyTimestampInvalid) {
158 ALOGE("Unexpectedly received invalid timestamp.");
159 vals_.actualPresentTime = 0;
160 vals_.earliestPresentTime = 0;
161 vals_.presentMargin = 0;
162 return;
163 }
164
165 vals_.actualPresentTime =
166 static_cast<uint64_t>(timestamp_actual_present_time_);
167 int64_t margin = (timestamp_composition_latch_time_ -
168 timestamp_render_complete_time_);
169 // Calculate vals_.earliestPresentTime, and potentially adjust
170 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
171 // is vals_.actualPresentTime. If we can subtract rdur (the duration
172 // of a refresh cycle) from vals_.earliestPresentTime (and also from
173 // vals_.presentMargin) and still leave a positive margin, then we can
174 // report to the application that it could have presented earlier than
175 // it did (per the extension specification). If for some reason, we
176 // can do this subtraction repeatedly, we do, since
177 // vals_.earliestPresentTime really is supposed to be the "earliest".
178 int64_t early_time = timestamp_actual_present_time_;
179 while ((margin > rdur) &&
180 ((early_time - rdur) > timestamp_composition_latch_time_)) {
181 early_time -= rdur;
182 margin -= rdur;
183 }
184 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
185 vals_.presentMargin = static_cast<uint64_t>(margin);
186 }
get_values(VkPastPresentationTimingGOOGLE * values) const187 void get_values(VkPastPresentationTimingGOOGLE* values) const {
188 *values = vals_;
189 }
190
191 public:
192 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
193
194 uint64_t native_frame_id_ { 0 };
195 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
196 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
197 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
198 int64_t timestamp_composition_latch_time_
199 { NATIVE_WINDOW_TIMESTAMP_PENDING };
200 };
201
202 struct Surface {
203 android::sp<ANativeWindow> window;
204 VkSwapchainKHR swapchain_handle;
205 uint64_t consumer_usage;
206 };
207
HandleFromSurface(Surface * surface)208 VkSurfaceKHR HandleFromSurface(Surface* surface) {
209 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
210 }
211
SurfaceFromHandle(VkSurfaceKHR handle)212 Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
213 return reinterpret_cast<Surface*>(handle);
214 }
215
216 // Maximum number of TimingInfo structs to keep per swapchain:
217 enum { MAX_TIMING_INFOS = 10 };
218 // Minimum number of frames to look for in the past (so we don't cause
219 // syncronous requests to Surface Flinger):
220 enum { MIN_NUM_FRAMES_AGO = 5 };
221
222 struct Swapchain {
Swapchainvulkan::driver::__anon425651d70110::Swapchain223 Swapchain(Surface& surface_,
224 uint32_t num_images_,
225 VkPresentModeKHR present_mode,
226 int pre_transform_)
227 : surface(surface_),
228 num_images(num_images_),
229 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
230 pre_transform(pre_transform_),
231 frame_timestamps_enabled(false),
232 acquire_next_image_timeout(-1),
233 shared(present_mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
234 present_mode ==
235 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
236 ANativeWindow* window = surface.window.get();
237 native_window_get_refresh_cycle_duration(
238 window,
239 &refresh_duration);
240 }
get_refresh_durationvulkan::driver::__anon425651d70110::Swapchain241 uint64_t get_refresh_duration()
242 {
243 ANativeWindow* window = surface.window.get();
244 native_window_get_refresh_cycle_duration(
245 window,
246 &refresh_duration);
247 return static_cast<uint64_t>(refresh_duration);
248
249 }
250
251 Surface& surface;
252 uint32_t num_images;
253 bool mailbox_mode;
254 int pre_transform;
255 bool frame_timestamps_enabled;
256 int64_t refresh_duration;
257 nsecs_t acquire_next_image_timeout;
258 bool shared;
259
260 struct Image {
Imagevulkan::driver::__anon425651d70110::Swapchain::Image261 Image()
262 : image(VK_NULL_HANDLE),
263 dequeue_fence(-1),
264 release_fence(-1),
265 dequeued(false) {}
266 VkImage image;
267 android::sp<ANativeWindowBuffer> buffer;
268 // The fence is only valid when the buffer is dequeued, and should be
269 // -1 any other time. When valid, we own the fd, and must ensure it is
270 // closed: either by closing it explicitly when queueing the buffer,
271 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
272 int dequeue_fence;
273 // This fence is a dup of the sync fd returned from the driver via
274 // vkQueueSignalReleaseImageANDROID upon vkQueuePresentKHR. We must
275 // ensure it is closed upon re-presenting or releasing the image.
276 int release_fence;
277 bool dequeued;
278 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
279
280 std::vector<TimingInfo> timing;
281 };
282
HandleFromSwapchain(Swapchain * swapchain)283 VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
284 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
285 }
286
SwapchainFromHandle(VkSwapchainKHR handle)287 Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
288 return reinterpret_cast<Swapchain*>(handle);
289 }
290
IsFencePending(int fd)291 static bool IsFencePending(int fd) {
292 if (fd < 0)
293 return false;
294
295 errno = 0;
296 return sync_wait(fd, 0 /* timeout */) == -1 && errno == ETIME;
297 }
298
ReleaseSwapchainImage(VkDevice device,ANativeWindow * window,int release_fence,Swapchain::Image & image,bool defer_if_pending)299 void ReleaseSwapchainImage(VkDevice device,
300 ANativeWindow* window,
301 int release_fence,
302 Swapchain::Image& image,
303 bool defer_if_pending) {
304 ATRACE_CALL();
305
306 ALOG_ASSERT(release_fence == -1 || image.dequeued,
307 "ReleaseSwapchainImage: can't provide a release fence for "
308 "non-dequeued images");
309
310 if (image.dequeued) {
311 if (release_fence >= 0) {
312 // We get here from vkQueuePresentKHR. The application is
313 // responsible for creating an execution dependency chain from
314 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
315 // (release_fence), so we can drop the dequeue_fence here.
316 if (image.dequeue_fence >= 0)
317 close(image.dequeue_fence);
318 } else {
319 // We get here during swapchain destruction, or various serious
320 // error cases e.g. when we can't create the release_fence during
321 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
322 // have already signalled, since the swapchain images are supposed
323 // to be idle before the swapchain is destroyed. In error cases,
324 // there may be rendering in flight to the image, but since we
325 // weren't able to create a release_fence, waiting for the
326 // dequeue_fence is about the best we can do.
327 release_fence = image.dequeue_fence;
328 }
329 image.dequeue_fence = -1;
330
331 if (window) {
332 window->cancelBuffer(window, image.buffer.get(), release_fence);
333 } else {
334 if (release_fence >= 0) {
335 sync_wait(release_fence, -1 /* forever */);
336 close(release_fence);
337 }
338 }
339 release_fence = -1;
340 image.dequeued = false;
341 }
342
343 if (defer_if_pending && IsFencePending(image.release_fence))
344 return;
345
346 if (image.release_fence >= 0) {
347 close(image.release_fence);
348 image.release_fence = -1;
349 }
350
351 if (image.image) {
352 ATRACE_BEGIN("DestroyImage");
353 GetData(device).driver.DestroyImage(device, image.image, nullptr);
354 ATRACE_END();
355 image.image = VK_NULL_HANDLE;
356 }
357
358 image.buffer.clear();
359 }
360
OrphanSwapchain(VkDevice device,Swapchain * swapchain)361 void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
362 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
363 return;
364 for (uint32_t i = 0; i < swapchain->num_images; i++) {
365 if (!swapchain->images[i].dequeued)
366 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i],
367 true);
368 }
369 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
370 swapchain->timing.clear();
371 }
372
get_num_ready_timings(Swapchain & swapchain)373 uint32_t get_num_ready_timings(Swapchain& swapchain) {
374 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
375 return 0;
376 }
377
378 uint32_t num_ready = 0;
379 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
380 for (uint32_t i = 0; i < num_timings; i++) {
381 TimingInfo& ti = swapchain.timing[i];
382 if (ti.ready()) {
383 // This TimingInfo is ready to be reported to the user. Add it
384 // to the num_ready.
385 num_ready++;
386 continue;
387 }
388 // This TimingInfo is not yet ready to be reported to the user,
389 // and so we should look for any available timestamps that
390 // might make it ready.
391 int64_t desired_present_time = 0;
392 int64_t render_complete_time = 0;
393 int64_t composition_latch_time = 0;
394 int64_t actual_present_time = 0;
395 // Obtain timestamps:
396 int err = native_window_get_frame_timestamps(
397 swapchain.surface.window.get(), ti.native_frame_id_,
398 &desired_present_time, &render_complete_time,
399 &composition_latch_time,
400 nullptr, //&first_composition_start_time,
401 nullptr, //&last_composition_start_time,
402 nullptr, //&composition_finish_time,
403 &actual_present_time,
404 nullptr, //&dequeue_ready_time,
405 nullptr /*&reads_done_time*/);
406
407 if (err != android::OK) {
408 continue;
409 }
410
411 // Record the timestamp(s) we received, and then see if this TimingInfo
412 // is ready to be reported to the user:
413 ti.timestamp_desired_present_time_ = desired_present_time;
414 ti.timestamp_actual_present_time_ = actual_present_time;
415 ti.timestamp_render_complete_time_ = render_complete_time;
416 ti.timestamp_composition_latch_time_ = composition_latch_time;
417
418 if (ti.ready()) {
419 // The TimingInfo has received enough timestamps, and should now
420 // use those timestamps to calculate the info that should be
421 // reported to the user:
422 ti.calculate(swapchain.refresh_duration);
423 num_ready++;
424 }
425 }
426 return num_ready;
427 }
428
copy_ready_timings(Swapchain & swapchain,uint32_t * count,VkPastPresentationTimingGOOGLE * timings)429 void copy_ready_timings(Swapchain& swapchain,
430 uint32_t* count,
431 VkPastPresentationTimingGOOGLE* timings) {
432 if (swapchain.timing.empty()) {
433 *count = 0;
434 return;
435 }
436
437 size_t last_ready = swapchain.timing.size() - 1;
438 while (!swapchain.timing[last_ready].ready()) {
439 if (last_ready == 0) {
440 *count = 0;
441 return;
442 }
443 last_ready--;
444 }
445
446 uint32_t num_copied = 0;
447 int32_t num_to_remove = 0;
448 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
449 const TimingInfo& ti = swapchain.timing[i];
450 if (ti.ready()) {
451 ti.get_values(&timings[num_copied]);
452 num_copied++;
453 }
454 num_to_remove++;
455 }
456
457 // Discard old frames that aren't ready if newer frames are ready.
458 // We don't expect to get the timing info for those old frames.
459 swapchain.timing.erase(swapchain.timing.begin(),
460 swapchain.timing.begin() + num_to_remove);
461
462 *count = num_copied;
463 }
464
GetNativePixelFormat(VkFormat format)465 android_pixel_format GetNativePixelFormat(VkFormat format) {
466 android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
467 switch (format) {
468 case VK_FORMAT_R8G8B8A8_UNORM:
469 case VK_FORMAT_R8G8B8A8_SRGB:
470 native_format = HAL_PIXEL_FORMAT_RGBA_8888;
471 break;
472 case VK_FORMAT_R5G6B5_UNORM_PACK16:
473 native_format = HAL_PIXEL_FORMAT_RGB_565;
474 break;
475 case VK_FORMAT_R16G16B16A16_SFLOAT:
476 native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
477 break;
478 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
479 native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
480 break;
481 default:
482 ALOGV("unsupported swapchain format %d", format);
483 break;
484 }
485 return native_format;
486 }
487
GetNativeDataspace(VkColorSpaceKHR colorspace)488 android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
489 switch (colorspace) {
490 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
491 return HAL_DATASPACE_V0_SRGB;
492 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
493 return HAL_DATASPACE_DISPLAY_P3;
494 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
495 return HAL_DATASPACE_V0_SCRGB_LINEAR;
496 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
497 return HAL_DATASPACE_V0_SCRGB;
498 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
499 return HAL_DATASPACE_DCI_P3_LINEAR;
500 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
501 return HAL_DATASPACE_DCI_P3;
502 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
503 return HAL_DATASPACE_V0_SRGB_LINEAR;
504 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
505 return HAL_DATASPACE_V0_SRGB;
506 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
507 return HAL_DATASPACE_BT2020_LINEAR;
508 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
509 return static_cast<android_dataspace>(
510 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
511 HAL_DATASPACE_RANGE_FULL);
512 case VK_COLOR_SPACE_DOLBYVISION_EXT:
513 return static_cast<android_dataspace>(
514 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
515 HAL_DATASPACE_RANGE_FULL);
516 case VK_COLOR_SPACE_HDR10_HLG_EXT:
517 return static_cast<android_dataspace>(
518 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_HLG |
519 HAL_DATASPACE_RANGE_FULL);
520 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
521 return static_cast<android_dataspace>(
522 HAL_DATASPACE_STANDARD_ADOBE_RGB |
523 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
524 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
525 return HAL_DATASPACE_ADOBE_RGB;
526
527 // Pass through is intended to allow app to provide data that is passed
528 // to the display system without modification.
529 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
530 return HAL_DATASPACE_ARBITRARY;
531
532 default:
533 // This indicates that we don't know about the
534 // dataspace specified and we should indicate that
535 // it's unsupported
536 return HAL_DATASPACE_UNKNOWN;
537 }
538 }
539
get_min_buffer_count(ANativeWindow * window,uint32_t * out_min_buffer_count)540 int get_min_buffer_count(ANativeWindow* window,
541 uint32_t* out_min_buffer_count) {
542 constexpr int kExtraBuffers = 2;
543
544 int err;
545 int min_undequeued_buffers;
546 err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
547 &min_undequeued_buffers);
548 if (err != android::OK || min_undequeued_buffers < 0) {
549 ALOGE(
550 "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) "
551 "value=%d",
552 strerror(-err), err, min_undequeued_buffers);
553 if (err == android::OK) {
554 err = android::UNKNOWN_ERROR;
555 }
556 return err;
557 }
558
559 *out_min_buffer_count =
560 static_cast<uint32_t>(min_undequeued_buffers + kExtraBuffers);
561 return android::OK;
562 }
563
564 } // anonymous namespace
565
566 VKAPI_ATTR
CreateAndroidSurfaceKHR(VkInstance instance,const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * allocator,VkSurfaceKHR * out_surface)567 VkResult CreateAndroidSurfaceKHR(
568 VkInstance instance,
569 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
570 const VkAllocationCallbacks* allocator,
571 VkSurfaceKHR* out_surface) {
572 ATRACE_CALL();
573
574 if (!allocator)
575 allocator = &GetData(instance).allocator;
576 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
577 alignof(Surface),
578 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
579 if (!mem)
580 return VK_ERROR_OUT_OF_HOST_MEMORY;
581 Surface* surface = new (mem) Surface;
582
583 surface->window = pCreateInfo->window;
584 surface->swapchain_handle = VK_NULL_HANDLE;
585 int err = native_window_get_consumer_usage(surface->window.get(),
586 &surface->consumer_usage);
587 if (err != android::OK) {
588 ALOGE("native_window_get_consumer_usage() failed: %s (%d)",
589 strerror(-err), err);
590 surface->~Surface();
591 allocator->pfnFree(allocator->pUserData, surface);
592 return VK_ERROR_SURFACE_LOST_KHR;
593 }
594
595 err =
596 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
597 if (err != android::OK) {
598 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
599 err);
600 surface->~Surface();
601 allocator->pfnFree(allocator->pUserData, surface);
602 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
603 }
604
605 *out_surface = HandleFromSurface(surface);
606 return VK_SUCCESS;
607 }
608
609 VKAPI_ATTR
DestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface_handle,const VkAllocationCallbacks * allocator)610 void DestroySurfaceKHR(VkInstance instance,
611 VkSurfaceKHR surface_handle,
612 const VkAllocationCallbacks* allocator) {
613 ATRACE_CALL();
614
615 Surface* surface = SurfaceFromHandle(surface_handle);
616 if (!surface)
617 return;
618 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
619 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
620 "destroyed VkSurfaceKHR 0x%" PRIx64
621 " has active VkSwapchainKHR 0x%" PRIx64,
622 reinterpret_cast<uint64_t>(surface_handle),
623 reinterpret_cast<uint64_t>(surface->swapchain_handle));
624 surface->~Surface();
625 if (!allocator)
626 allocator = &GetData(instance).allocator;
627 allocator->pfnFree(allocator->pUserData, surface);
628 }
629
630 VKAPI_ATTR
GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice,uint32_t,VkSurfaceKHR,VkBool32 * supported)631 VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
632 uint32_t /*queue_family*/,
633 VkSurfaceKHR /*surface_handle*/,
634 VkBool32* supported) {
635 *supported = VK_TRUE;
636 return VK_SUCCESS;
637 }
638
639 VKAPI_ATTR
GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilitiesKHR * capabilities)640 VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
641 VkPhysicalDevice /*pdev*/,
642 VkSurfaceKHR surface,
643 VkSurfaceCapabilitiesKHR* capabilities) {
644 ATRACE_CALL();
645
646 int err;
647 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
648
649 int width, height;
650 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
651 if (err != android::OK) {
652 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
653 strerror(-err), err);
654 return VK_ERROR_SURFACE_LOST_KHR;
655 }
656 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
657 if (err != android::OK) {
658 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
659 strerror(-err), err);
660 return VK_ERROR_SURFACE_LOST_KHR;
661 }
662
663 int transform_hint;
664 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
665 if (err != android::OK) {
666 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
667 strerror(-err), err);
668 return VK_ERROR_SURFACE_LOST_KHR;
669 }
670
671 int max_buffer_count;
672 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count);
673 if (err != android::OK) {
674 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
675 strerror(-err), err);
676 return VK_ERROR_SURFACE_LOST_KHR;
677 }
678 capabilities->minImageCount = max_buffer_count == 1 ? 1 : 2;
679 capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
680
681 capabilities->currentExtent =
682 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
683
684 // TODO(http://b/134182502): Figure out what the max extent should be.
685 capabilities->minImageExtent = VkExtent2D{1, 1};
686 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
687
688 capabilities->maxImageArrayLayers = 1;
689
690 capabilities->supportedTransforms = kSupportedTransforms;
691 capabilities->currentTransform =
692 TranslateNativeToVulkanTransform(transform_hint);
693
694 // On Android, window composition is a WindowManager property, not something
695 // associated with the bufferqueue. It can't be changed from here.
696 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
697
698 capabilities->supportedUsageFlags =
699 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
700 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
701 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
702 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
703
704 return VK_SUCCESS;
705 }
706
707 VKAPI_ATTR
GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,VkSurfaceKHR surface_handle,uint32_t * count,VkSurfaceFormatKHR * formats)708 VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
709 VkSurfaceKHR surface_handle,
710 uint32_t* count,
711 VkSurfaceFormatKHR* formats) {
712 ATRACE_CALL();
713
714 const InstanceData& instance_data = GetData(pdev);
715
716 bool wide_color_support = false;
717 Surface& surface = *SurfaceFromHandle(surface_handle);
718 int err = native_window_get_wide_color_support(surface.window.get(),
719 &wide_color_support);
720 if (err) {
721 return VK_ERROR_SURFACE_LOST_KHR;
722 }
723 ALOGV("wide_color_support is: %d", wide_color_support);
724 wide_color_support =
725 wide_color_support &&
726 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
727
728 AHardwareBuffer_Desc desc = {};
729 desc.width = 1;
730 desc.height = 1;
731 desc.layers = 1;
732 desc.usage = surface.consumer_usage |
733 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
734 AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
735
736 // We must support R8G8B8A8
737 std::vector<VkSurfaceFormatKHR> all_formats = {
738 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
739 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}};
740
741 if (wide_color_support) {
742 all_formats.emplace_back(VkSurfaceFormatKHR{
743 VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
744 all_formats.emplace_back(VkSurfaceFormatKHR{
745 VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
746 }
747
748 desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
749 if (AHardwareBuffer_isSupported(&desc)) {
750 all_formats.emplace_back(VkSurfaceFormatKHR{
751 VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
752 }
753
754 desc.format = AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
755 if (AHardwareBuffer_isSupported(&desc)) {
756 all_formats.emplace_back(VkSurfaceFormatKHR{
757 VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
758 if (wide_color_support) {
759 all_formats.emplace_back(
760 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
761 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT});
762 all_formats.emplace_back(
763 VkSurfaceFormatKHR{VK_FORMAT_R16G16B16A16_SFLOAT,
764 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT});
765 }
766 }
767
768 desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
769 if (AHardwareBuffer_isSupported(&desc)) {
770 all_formats.emplace_back(
771 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
772 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
773 if (wide_color_support) {
774 all_formats.emplace_back(
775 VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,
776 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
777 }
778 }
779
780 VkResult result = VK_SUCCESS;
781 if (formats) {
782 uint32_t transfer_count = all_formats.size();
783 if (transfer_count > *count) {
784 transfer_count = *count;
785 result = VK_INCOMPLETE;
786 }
787 std::copy(all_formats.begin(), all_formats.begin() + transfer_count,
788 formats);
789 *count = transfer_count;
790 } else {
791 *count = all_formats.size();
792 }
793
794 return result;
795 }
796
797 VKAPI_ATTR
GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkSurfaceCapabilities2KHR * pSurfaceCapabilities)798 VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
799 VkPhysicalDevice physicalDevice,
800 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
801 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
802 ATRACE_CALL();
803
804 VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
805 physicalDevice, pSurfaceInfo->surface,
806 &pSurfaceCapabilities->surfaceCapabilities);
807
808 VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
809 while (caps->pNext) {
810 caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
811
812 switch (caps->sType) {
813 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
814 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
815 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
816 caps);
817 // Claim same set of usage flags are supported for
818 // shared present modes as for other modes.
819 shared_caps->sharedPresentSupportedUsageFlags =
820 pSurfaceCapabilities->surfaceCapabilities
821 .supportedUsageFlags;
822 } break;
823
824 default:
825 // Ignore all other extension structs
826 break;
827 }
828 }
829
830 return result;
831 }
832
833 VKAPI_ATTR
GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pSurfaceFormatCount,VkSurfaceFormat2KHR * pSurfaceFormats)834 VkResult GetPhysicalDeviceSurfaceFormats2KHR(
835 VkPhysicalDevice physicalDevice,
836 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
837 uint32_t* pSurfaceFormatCount,
838 VkSurfaceFormat2KHR* pSurfaceFormats) {
839 ATRACE_CALL();
840
841 if (!pSurfaceFormats) {
842 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
843 pSurfaceInfo->surface,
844 pSurfaceFormatCount, nullptr);
845 } else {
846 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
847 // after the call.
848 std::vector<VkSurfaceFormatKHR> surface_formats(*pSurfaceFormatCount);
849 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
850 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
851 surface_formats.data());
852
853 if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
854 // marshal results individually due to stride difference.
855 // completely ignore any chained extension structs.
856 uint32_t formats_to_marshal = *pSurfaceFormatCount;
857 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
858 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
859 }
860 }
861
862 return result;
863 }
864 }
865
866 VKAPI_ATTR
GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,VkSurfaceKHR surface,uint32_t * count,VkPresentModeKHR * modes)867 VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
868 VkSurfaceKHR surface,
869 uint32_t* count,
870 VkPresentModeKHR* modes) {
871 ATRACE_CALL();
872
873 int err;
874 int query_value;
875 uint32_t min_buffer_count;
876 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
877
878 err = get_min_buffer_count(window, &min_buffer_count);
879 if (err != android::OK) {
880 return VK_ERROR_SURFACE_LOST_KHR;
881 }
882
883 err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
884 if (err != android::OK || query_value < 0) {
885 ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
886 strerror(-err), err, query_value);
887 return VK_ERROR_SURFACE_LOST_KHR;
888 }
889 uint32_t max_buffer_count = static_cast<uint32_t>(query_value);
890
891 std::vector<VkPresentModeKHR> present_modes;
892 if (min_buffer_count < max_buffer_count)
893 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
894 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
895
896 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
897 QueryPresentationProperties(pdev, &present_properties);
898 if (present_properties.sharedImage) {
899 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
900 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
901 }
902
903 uint32_t num_modes = uint32_t(present_modes.size());
904
905 VkResult result = VK_SUCCESS;
906 if (modes) {
907 if (*count < num_modes)
908 result = VK_INCOMPLETE;
909 *count = std::min(*count, num_modes);
910 std::copy_n(present_modes.data(), *count, modes);
911 } else {
912 *count = num_modes;
913 }
914 return result;
915 }
916
917 VKAPI_ATTR
GetDeviceGroupPresentCapabilitiesKHR(VkDevice,VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities)918 VkResult GetDeviceGroupPresentCapabilitiesKHR(
919 VkDevice,
920 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
921 ATRACE_CALL();
922
923 ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
924 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
925 "vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
926 "VkDeviceGroupPresentCapabilitiesKHR structure type %d",
927 pDeviceGroupPresentCapabilities->sType);
928
929 memset(pDeviceGroupPresentCapabilities->presentMask, 0,
930 sizeof(pDeviceGroupPresentCapabilities->presentMask));
931
932 // assume device group of size 1
933 pDeviceGroupPresentCapabilities->presentMask[0] = 1 << 0;
934 pDeviceGroupPresentCapabilities->modes =
935 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
936
937 return VK_SUCCESS;
938 }
939
940 VKAPI_ATTR
GetDeviceGroupSurfacePresentModesKHR(VkDevice,VkSurfaceKHR,VkDeviceGroupPresentModeFlagsKHR * pModes)941 VkResult GetDeviceGroupSurfacePresentModesKHR(
942 VkDevice,
943 VkSurfaceKHR,
944 VkDeviceGroupPresentModeFlagsKHR* pModes) {
945 ATRACE_CALL();
946
947 *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
948 return VK_SUCCESS;
949 }
950
951 VKAPI_ATTR
GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,VkSurfaceKHR surface,uint32_t * pRectCount,VkRect2D * pRects)952 VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
953 VkSurfaceKHR surface,
954 uint32_t* pRectCount,
955 VkRect2D* pRects) {
956 ATRACE_CALL();
957
958 if (!pRects) {
959 *pRectCount = 1;
960 } else {
961 uint32_t count = std::min(*pRectCount, 1u);
962 bool incomplete = *pRectCount < 1;
963
964 *pRectCount = count;
965
966 if (incomplete) {
967 return VK_INCOMPLETE;
968 }
969
970 int err;
971 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
972
973 int width = 0, height = 0;
974 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
975 if (err != android::OK) {
976 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
977 strerror(-err), err);
978 }
979 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
980 if (err != android::OK) {
981 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
982 strerror(-err), err);
983 }
984
985 pRects[0].offset.x = 0;
986 pRects[0].offset.y = 0;
987 pRects[0].extent = VkExtent2D{static_cast<uint32_t>(width),
988 static_cast<uint32_t>(height)};
989 }
990 return VK_SUCCESS;
991 }
992
DestroySwapchainInternal(VkDevice device,VkSwapchainKHR swapchain_handle,const VkAllocationCallbacks * allocator)993 static void DestroySwapchainInternal(VkDevice device,
994 VkSwapchainKHR swapchain_handle,
995 const VkAllocationCallbacks* allocator) {
996 ATRACE_CALL();
997
998 const auto& dispatch = GetData(device).driver;
999 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
1000 if (!swapchain) {
1001 return;
1002 }
1003
1004 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1005 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1006
1007 if (window && swapchain->frame_timestamps_enabled) {
1008 native_window_enable_frame_timestamps(window, false);
1009 }
1010
1011 for (uint32_t i = 0; i < swapchain->num_images; i++) {
1012 ReleaseSwapchainImage(device, window, -1, swapchain->images[i], false);
1013 }
1014
1015 if (active) {
1016 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1017 }
1018
1019 if (!allocator) {
1020 allocator = &GetData(device).allocator;
1021 }
1022
1023 swapchain->~Swapchain();
1024 allocator->pfnFree(allocator->pUserData, swapchain);
1025 }
1026
1027 VKAPI_ATTR
CreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * create_info,const VkAllocationCallbacks * allocator,VkSwapchainKHR * swapchain_handle)1028 VkResult CreateSwapchainKHR(VkDevice device,
1029 const VkSwapchainCreateInfoKHR* create_info,
1030 const VkAllocationCallbacks* allocator,
1031 VkSwapchainKHR* swapchain_handle) {
1032 ATRACE_CALL();
1033
1034 int err;
1035 VkResult result = VK_SUCCESS;
1036
1037 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
1038 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
1039 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
1040 " oldSwapchain=0x%" PRIx64,
1041 reinterpret_cast<uint64_t>(create_info->surface),
1042 create_info->minImageCount, create_info->imageFormat,
1043 create_info->imageColorSpace, create_info->imageExtent.width,
1044 create_info->imageExtent.height, create_info->imageUsage,
1045 create_info->preTransform, create_info->presentMode,
1046 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1047
1048 if (!allocator)
1049 allocator = &GetData(device).allocator;
1050
1051 android_pixel_format native_pixel_format =
1052 GetNativePixelFormat(create_info->imageFormat);
1053 android_dataspace native_dataspace =
1054 GetNativeDataspace(create_info->imageColorSpace);
1055 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
1056 ALOGE(
1057 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
1058 "failed: Unsupported color space",
1059 create_info->imageColorSpace);
1060 return VK_ERROR_INITIALIZATION_FAILED;
1061 }
1062
1063 ALOGV_IF(create_info->imageArrayLayers != 1,
1064 "swapchain imageArrayLayers=%u not supported",
1065 create_info->imageArrayLayers);
1066 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
1067 "swapchain preTransform=%#x not supported",
1068 create_info->preTransform);
1069 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
1070 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
1071 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1072 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
1073 "swapchain presentMode=%u not supported",
1074 create_info->presentMode);
1075
1076 Surface& surface = *SurfaceFromHandle(create_info->surface);
1077
1078 if (surface.swapchain_handle != create_info->oldSwapchain) {
1079 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
1080 " because it already has active swapchain 0x%" PRIx64
1081 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
1082 reinterpret_cast<uint64_t>(create_info->surface),
1083 reinterpret_cast<uint64_t>(surface.swapchain_handle),
1084 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
1085 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
1086 }
1087 if (create_info->oldSwapchain != VK_NULL_HANDLE)
1088 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
1089
1090 // -- Reset the native window --
1091 // The native window might have been used previously, and had its properties
1092 // changed from defaults. That will affect the answer we get for queries
1093 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
1094 // attempt such queries.
1095
1096 // The native window only allows dequeueing all buffers before any have
1097 // been queued, since after that point at least one is assumed to be in
1098 // non-FREE state at any given time. Disconnecting and re-connecting
1099 // orphans the previous buffers, getting us back to the state where we can
1100 // dequeue all buffers.
1101 //
1102 // TODO(http://b/134186185) recycle swapchain images more efficiently
1103 ANativeWindow* window = surface.window.get();
1104 err = native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
1105 ALOGW_IF(err != android::OK, "native_window_api_disconnect failed: %s (%d)",
1106 strerror(-err), err);
1107 err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
1108 ALOGW_IF(err != android::OK, "native_window_api_connect failed: %s (%d)",
1109 strerror(-err), err);
1110
1111 err =
1112 window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, nsecs_t{-1});
1113 if (err != android::OK) {
1114 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1115 strerror(-err), err);
1116 return VK_ERROR_SURFACE_LOST_KHR;
1117 }
1118
1119 int swap_interval =
1120 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
1121 err = window->setSwapInterval(window, swap_interval);
1122 if (err != android::OK) {
1123 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
1124 strerror(-err), err);
1125 return VK_ERROR_SURFACE_LOST_KHR;
1126 }
1127
1128 err = native_window_set_shared_buffer_mode(window, false);
1129 if (err != android::OK) {
1130 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
1131 strerror(-err), err);
1132 return VK_ERROR_SURFACE_LOST_KHR;
1133 }
1134
1135 err = native_window_set_auto_refresh(window, false);
1136 if (err != android::OK) {
1137 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
1138 strerror(-err), err);
1139 return VK_ERROR_SURFACE_LOST_KHR;
1140 }
1141
1142 // -- Configure the native window --
1143
1144 const auto& dispatch = GetData(device).driver;
1145
1146 err = native_window_set_buffers_format(window, native_pixel_format);
1147 if (err != android::OK) {
1148 ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)",
1149 native_pixel_format, strerror(-err), err);
1150 return VK_ERROR_SURFACE_LOST_KHR;
1151 }
1152 err = native_window_set_buffers_data_space(window, native_dataspace);
1153 if (err != android::OK) {
1154 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
1155 native_dataspace, strerror(-err), err);
1156 return VK_ERROR_SURFACE_LOST_KHR;
1157 }
1158
1159 err = native_window_set_buffers_dimensions(
1160 window, static_cast<int>(create_info->imageExtent.width),
1161 static_cast<int>(create_info->imageExtent.height));
1162 if (err != android::OK) {
1163 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
1164 create_info->imageExtent.width, create_info->imageExtent.height,
1165 strerror(-err), err);
1166 return VK_ERROR_SURFACE_LOST_KHR;
1167 }
1168
1169 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
1170 // applied during rendering. native_window_set_transform() expects the
1171 // inverse: the transform the app is requesting that the compositor perform
1172 // during composition. With native windows, pre-transform works by rendering
1173 // with the same transform the compositor is applying (as in Vulkan), but
1174 // then requesting the inverse transform, so that when the compositor does
1175 // it's job the two transforms cancel each other out and the compositor ends
1176 // up applying an identity transform to the app's buffer.
1177 err = native_window_set_buffers_transform(
1178 window, InvertTransformToNative(create_info->preTransform));
1179 if (err != android::OK) {
1180 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
1181 InvertTransformToNative(create_info->preTransform),
1182 strerror(-err), err);
1183 return VK_ERROR_SURFACE_LOST_KHR;
1184 }
1185
1186 err = native_window_set_scaling_mode(
1187 window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
1188 if (err != android::OK) {
1189 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
1190 strerror(-err), err);
1191 return VK_ERROR_SURFACE_LOST_KHR;
1192 }
1193
1194 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
1195 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
1196 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1197 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
1198 err = native_window_set_shared_buffer_mode(window, true);
1199 if (err != android::OK) {
1200 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
1201 return VK_ERROR_SURFACE_LOST_KHR;
1202 }
1203 }
1204
1205 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
1206 err = native_window_set_auto_refresh(window, true);
1207 if (err != android::OK) {
1208 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
1209 return VK_ERROR_SURFACE_LOST_KHR;
1210 }
1211 }
1212
1213 uint32_t min_buffer_count;
1214 err = get_min_buffer_count(window, &min_buffer_count);
1215 if (err != android::OK) {
1216 return VK_ERROR_SURFACE_LOST_KHR;
1217 }
1218
1219 uint32_t num_images =
1220 std::max(min_buffer_count, create_info->minImageCount);
1221
1222 // Lower layer insists that we have at least two buffers. This is wasteful
1223 // and we'd like to relax it in the shared case, but not all the pieces are
1224 // in place for that to work yet. Note we only lie to the lower layer-- we
1225 // don't want to give the app back a swapchain with extra images (which they
1226 // can't actually use!).
1227 err = native_window_set_buffer_count(window, std::max(2u, num_images));
1228 if (err != android::OK) {
1229 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
1230 strerror(-err), err);
1231 return VK_ERROR_SURFACE_LOST_KHR;
1232 }
1233
1234 // In shared mode the num_images must be one regardless of how many
1235 // buffers were allocated for the buffer queue.
1236 if (swapchain_image_usage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) {
1237 num_images = 1;
1238 }
1239
1240 int32_t legacy_usage = 0;
1241 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
1242 uint64_t consumer_usage, producer_usage;
1243 ATRACE_BEGIN("GetSwapchainGrallocUsage2ANDROID");
1244 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1245 device, create_info->imageFormat, create_info->imageUsage,
1246 swapchain_image_usage, &consumer_usage, &producer_usage);
1247 ATRACE_END();
1248 if (result != VK_SUCCESS) {
1249 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
1250 return VK_ERROR_SURFACE_LOST_KHR;
1251 }
1252 legacy_usage =
1253 android_convertGralloc1To0Usage(producer_usage, consumer_usage);
1254 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
1255 ATRACE_BEGIN("GetSwapchainGrallocUsageANDROID");
1256 result = dispatch.GetSwapchainGrallocUsageANDROID(
1257 device, create_info->imageFormat, create_info->imageUsage,
1258 &legacy_usage);
1259 ATRACE_END();
1260 if (result != VK_SUCCESS) {
1261 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
1262 return VK_ERROR_SURFACE_LOST_KHR;
1263 }
1264 }
1265 uint64_t native_usage = static_cast<uint64_t>(legacy_usage);
1266
1267 bool createProtectedSwapchain = false;
1268 if (create_info->flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
1269 createProtectedSwapchain = true;
1270 native_usage |= BufferUsage::PROTECTED;
1271 }
1272 err = native_window_set_usage(window, native_usage);
1273 if (err != android::OK) {
1274 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
1275 return VK_ERROR_SURFACE_LOST_KHR;
1276 }
1277
1278 int transform_hint;
1279 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
1280 if (err != android::OK) {
1281 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1282 strerror(-err), err);
1283 return VK_ERROR_SURFACE_LOST_KHR;
1284 }
1285
1286 // -- Allocate our Swapchain object --
1287 // After this point, we must deallocate the swapchain on error.
1288
1289 void* mem = allocator->pfnAllocation(allocator->pUserData,
1290 sizeof(Swapchain), alignof(Swapchain),
1291 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1292 if (!mem)
1293 return VK_ERROR_OUT_OF_HOST_MEMORY;
1294 Swapchain* swapchain = new (mem)
1295 Swapchain(surface, num_images, create_info->presentMode,
1296 TranslateVulkanToNativeTransform(create_info->preTransform));
1297 // -- Dequeue all buffers and create a VkImage for each --
1298 // Any failures during or after this must cancel the dequeued buffers.
1299
1300 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1301 #pragma clang diagnostic push
1302 #pragma clang diagnostic ignored "-Wold-style-cast"
1303 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1304 #pragma clang diagnostic pop
1305 .pNext = nullptr,
1306 .usage = swapchain_image_usage,
1307 };
1308 VkNativeBufferANDROID image_native_buffer = {
1309 #pragma clang diagnostic push
1310 #pragma clang diagnostic ignored "-Wold-style-cast"
1311 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1312 #pragma clang diagnostic pop
1313 .pNext = &swapchain_image_create,
1314 };
1315 VkImageCreateInfo image_create = {
1316 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1317 .pNext = &image_native_buffer,
1318 .flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
1319 .imageType = VK_IMAGE_TYPE_2D,
1320 .format = create_info->imageFormat,
1321 .extent = {0, 0, 1},
1322 .mipLevels = 1,
1323 .arrayLayers = 1,
1324 .samples = VK_SAMPLE_COUNT_1_BIT,
1325 .tiling = VK_IMAGE_TILING_OPTIMAL,
1326 .usage = create_info->imageUsage,
1327 .sharingMode = create_info->imageSharingMode,
1328 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
1329 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1330 };
1331
1332 for (uint32_t i = 0; i < num_images; i++) {
1333 Swapchain::Image& img = swapchain->images[i];
1334
1335 ANativeWindowBuffer* buffer;
1336 err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
1337 if (err != android::OK) {
1338 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
1339 switch (-err) {
1340 case ENOMEM:
1341 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
1342 break;
1343 default:
1344 result = VK_ERROR_SURFACE_LOST_KHR;
1345 break;
1346 }
1347 break;
1348 }
1349 img.buffer = buffer;
1350 img.dequeued = true;
1351
1352 image_create.extent =
1353 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1354 static_cast<uint32_t>(img.buffer->height),
1355 1};
1356 image_native_buffer.handle = img.buffer->handle;
1357 image_native_buffer.stride = img.buffer->stride;
1358 image_native_buffer.format = img.buffer->format;
1359 image_native_buffer.usage = int(img.buffer->usage);
1360 android_convertGralloc0To1Usage(int(img.buffer->usage),
1361 &image_native_buffer.usage2.producer,
1362 &image_native_buffer.usage2.consumer);
1363
1364 ATRACE_BEGIN("CreateImage");
1365 result =
1366 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
1367 ATRACE_END();
1368 if (result != VK_SUCCESS) {
1369 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1370 break;
1371 }
1372 }
1373
1374 // -- Cancel all buffers, returning them to the queue --
1375 // If an error occurred before, also destroy the VkImage and release the
1376 // buffer reference. Otherwise, we retain a strong reference to the buffer.
1377 for (uint32_t i = 0; i < num_images; i++) {
1378 Swapchain::Image& img = swapchain->images[i];
1379 if (img.dequeued) {
1380 if (!swapchain->shared) {
1381 window->cancelBuffer(window, img.buffer.get(),
1382 img.dequeue_fence);
1383 img.dequeue_fence = -1;
1384 img.dequeued = false;
1385 }
1386 }
1387 }
1388
1389 if (result != VK_SUCCESS) {
1390 DestroySwapchainInternal(device, HandleFromSwapchain(swapchain),
1391 allocator);
1392 return result;
1393 }
1394
1395 if (transform_hint != swapchain->pre_transform) {
1396 // Log that the app is not doing pre-rotation.
1397 android::GraphicsEnv::getInstance().setTargetStats(
1398 android::GpuStatsInfo::Stats::FALSE_PREROTATION);
1399 }
1400
1401 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1402 *swapchain_handle = surface.swapchain_handle;
1403 return VK_SUCCESS;
1404 }
1405
1406 VKAPI_ATTR
DestroySwapchainKHR(VkDevice device,VkSwapchainKHR swapchain_handle,const VkAllocationCallbacks * allocator)1407 void DestroySwapchainKHR(VkDevice device,
1408 VkSwapchainKHR swapchain_handle,
1409 const VkAllocationCallbacks* allocator) {
1410 ATRACE_CALL();
1411
1412 DestroySwapchainInternal(device, swapchain_handle, allocator);
1413 }
1414
1415 VKAPI_ATTR
GetSwapchainImagesKHR(VkDevice,VkSwapchainKHR swapchain_handle,uint32_t * count,VkImage * images)1416 VkResult GetSwapchainImagesKHR(VkDevice,
1417 VkSwapchainKHR swapchain_handle,
1418 uint32_t* count,
1419 VkImage* images) {
1420 ATRACE_CALL();
1421
1422 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1423 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1424 "getting images for non-active swapchain 0x%" PRIx64
1425 "; only dequeued image handles are valid",
1426 reinterpret_cast<uint64_t>(swapchain_handle));
1427 VkResult result = VK_SUCCESS;
1428 if (images) {
1429 uint32_t n = swapchain.num_images;
1430 if (*count < swapchain.num_images) {
1431 n = *count;
1432 result = VK_INCOMPLETE;
1433 }
1434 for (uint32_t i = 0; i < n; i++)
1435 images[i] = swapchain.images[i].image;
1436 *count = n;
1437 } else {
1438 *count = swapchain.num_images;
1439 }
1440 return result;
1441 }
1442
1443 VKAPI_ATTR
AcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain_handle,uint64_t timeout,VkSemaphore semaphore,VkFence vk_fence,uint32_t * image_index)1444 VkResult AcquireNextImageKHR(VkDevice device,
1445 VkSwapchainKHR swapchain_handle,
1446 uint64_t timeout,
1447 VkSemaphore semaphore,
1448 VkFence vk_fence,
1449 uint32_t* image_index) {
1450 ATRACE_CALL();
1451
1452 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1453 ANativeWindow* window = swapchain.surface.window.get();
1454 VkResult result;
1455 int err;
1456
1457 if (swapchain.surface.swapchain_handle != swapchain_handle)
1458 return VK_ERROR_OUT_OF_DATE_KHR;
1459
1460 if (swapchain.shared) {
1461 // In shared mode, we keep the buffer dequeued all the time, so we don't
1462 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1463 // the semaphore and fence passed to us will be signalled.
1464 *image_index = 0;
1465 result = GetData(device).driver.AcquireImageANDROID(
1466 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1467 return result;
1468 }
1469
1470 const nsecs_t acquire_next_image_timeout =
1471 timeout > (uint64_t)std::numeric_limits<nsecs_t>::max() ? -1 : timeout;
1472 if (acquire_next_image_timeout != swapchain.acquire_next_image_timeout) {
1473 // Cache the timeout to avoid the duplicate binder cost.
1474 err = window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT,
1475 acquire_next_image_timeout);
1476 if (err != android::OK) {
1477 ALOGE("window->perform(SET_DEQUEUE_TIMEOUT) failed: %s (%d)",
1478 strerror(-err), err);
1479 return VK_ERROR_SURFACE_LOST_KHR;
1480 }
1481 swapchain.acquire_next_image_timeout = acquire_next_image_timeout;
1482 }
1483
1484 ANativeWindowBuffer* buffer;
1485 int fence_fd;
1486 err = window->dequeueBuffer(window, &buffer, &fence_fd);
1487 if (err == android::TIMED_OUT || err == android::INVALID_OPERATION) {
1488 ALOGW("dequeueBuffer timed out: %s (%d)", strerror(-err), err);
1489 return timeout ? VK_TIMEOUT : VK_NOT_READY;
1490 } else if (err != android::OK) {
1491 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1492 return VK_ERROR_SURFACE_LOST_KHR;
1493 }
1494
1495 uint32_t idx;
1496 for (idx = 0; idx < swapchain.num_images; idx++) {
1497 if (swapchain.images[idx].buffer.get() == buffer) {
1498 swapchain.images[idx].dequeued = true;
1499 swapchain.images[idx].dequeue_fence = fence_fd;
1500 break;
1501 }
1502 }
1503 if (idx == swapchain.num_images) {
1504 ALOGE("dequeueBuffer returned unrecognized buffer");
1505 window->cancelBuffer(window, buffer, fence_fd);
1506 return VK_ERROR_OUT_OF_DATE_KHR;
1507 }
1508
1509 int fence_clone = -1;
1510 if (fence_fd != -1) {
1511 fence_clone = dup(fence_fd);
1512 if (fence_clone == -1) {
1513 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1514 strerror(errno), errno);
1515 sync_wait(fence_fd, -1 /* forever */);
1516 }
1517 }
1518
1519 result = GetData(device).driver.AcquireImageANDROID(
1520 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
1521 if (result != VK_SUCCESS) {
1522 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1523 // even if the call fails. We could close it ourselves on failure, but
1524 // that would create a race condition if the driver closes it on a
1525 // failure path: some other thread might create an fd with the same
1526 // number between the time the driver closes it and the time we close
1527 // it. We must assume one of: the driver *always* closes it even on
1528 // failure, or *never* closes it on failure.
1529 window->cancelBuffer(window, buffer, fence_fd);
1530 swapchain.images[idx].dequeued = false;
1531 swapchain.images[idx].dequeue_fence = -1;
1532 return result;
1533 }
1534
1535 *image_index = idx;
1536 return VK_SUCCESS;
1537 }
1538
1539 VKAPI_ATTR
AcquireNextImage2KHR(VkDevice device,const VkAcquireNextImageInfoKHR * pAcquireInfo,uint32_t * pImageIndex)1540 VkResult AcquireNextImage2KHR(VkDevice device,
1541 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1542 uint32_t* pImageIndex) {
1543 ATRACE_CALL();
1544
1545 return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
1546 pAcquireInfo->timeout, pAcquireInfo->semaphore,
1547 pAcquireInfo->fence, pImageIndex);
1548 }
1549
WorstPresentResult(VkResult a,VkResult b)1550 static VkResult WorstPresentResult(VkResult a, VkResult b) {
1551 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1552 // (in spec version 1.0.14).
1553 static const VkResult kWorstToBest[] = {
1554 VK_ERROR_DEVICE_LOST,
1555 VK_ERROR_SURFACE_LOST_KHR,
1556 VK_ERROR_OUT_OF_DATE_KHR,
1557 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1558 VK_ERROR_OUT_OF_HOST_MEMORY,
1559 VK_SUBOPTIMAL_KHR,
1560 };
1561 for (auto result : kWorstToBest) {
1562 if (a == result || b == result)
1563 return result;
1564 }
1565 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1566 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1567 return a != VK_SUCCESS ? a : b;
1568 }
1569
1570 VKAPI_ATTR
QueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * present_info)1571 VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
1572 ATRACE_CALL();
1573
1574 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1575 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1576 present_info->sType);
1577
1578 VkDevice device = GetData(queue).driver_device;
1579 const auto& dispatch = GetData(queue).driver;
1580 VkResult final_result = VK_SUCCESS;
1581
1582 // Look at the pNext chain for supported extension structs:
1583 const VkPresentRegionsKHR* present_regions = nullptr;
1584 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
1585 const VkPresentRegionsKHR* next =
1586 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1587 while (next) {
1588 switch (next->sType) {
1589 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1590 present_regions = next;
1591 break;
1592 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
1593 present_times =
1594 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1595 break;
1596 default:
1597 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1598 next->sType);
1599 break;
1600 }
1601 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1602 }
1603 ALOGV_IF(
1604 present_regions &&
1605 present_regions->swapchainCount != present_info->swapchainCount,
1606 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
1607 ALOGV_IF(present_times &&
1608 present_times->swapchainCount != present_info->swapchainCount,
1609 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1610 "VkPresentInfo::swapchainCount");
1611 const VkPresentRegionKHR* regions =
1612 (present_regions) ? present_regions->pRegions : nullptr;
1613 const VkPresentTimeGOOGLE* times =
1614 (present_times) ? present_times->pTimes : nullptr;
1615 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
1616 android_native_rect_t* rects = nullptr;
1617 uint32_t nrects = 0;
1618
1619 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1620 Swapchain& swapchain =
1621 *SwapchainFromHandle(present_info->pSwapchains[sc]);
1622 uint32_t image_idx = present_info->pImageIndices[sc];
1623 Swapchain::Image& img = swapchain.images[image_idx];
1624 const VkPresentRegionKHR* region =
1625 (regions && !swapchain.mailbox_mode) ? ®ions[sc] : nullptr;
1626 const VkPresentTimeGOOGLE* time = (times) ? ×[sc] : nullptr;
1627 VkResult swapchain_result = VK_SUCCESS;
1628 VkResult result;
1629 int err;
1630
1631 int fence = -1;
1632 result = dispatch.QueueSignalReleaseImageANDROID(
1633 queue, present_info->waitSemaphoreCount,
1634 present_info->pWaitSemaphores, img.image, &fence);
1635 if (result != VK_SUCCESS) {
1636 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
1637 swapchain_result = result;
1638 }
1639 if (img.release_fence >= 0)
1640 close(img.release_fence);
1641 img.release_fence = fence < 0 ? -1 : dup(fence);
1642
1643 if (swapchain.surface.swapchain_handle ==
1644 present_info->pSwapchains[sc]) {
1645 ANativeWindow* window = swapchain.surface.window.get();
1646 if (swapchain_result == VK_SUCCESS) {
1647 if (region) {
1648 // Process the incremental-present hint for this swapchain:
1649 uint32_t rcount = region->rectangleCount;
1650 if (rcount > nrects) {
1651 android_native_rect_t* new_rects =
1652 static_cast<android_native_rect_t*>(
1653 allocator->pfnReallocation(
1654 allocator->pUserData, rects,
1655 sizeof(android_native_rect_t) * rcount,
1656 alignof(android_native_rect_t),
1657 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1658 if (new_rects) {
1659 rects = new_rects;
1660 nrects = rcount;
1661 } else {
1662 rcount = 0; // Ignore the hint for this swapchain
1663 }
1664 }
1665 for (uint32_t r = 0; r < rcount; ++r) {
1666 if (region->pRectangles[r].layer > 0) {
1667 ALOGV(
1668 "vkQueuePresentKHR ignoring invalid layer "
1669 "(%u); using layer 0 instead",
1670 region->pRectangles[r].layer);
1671 }
1672 int x = region->pRectangles[r].offset.x;
1673 int y = region->pRectangles[r].offset.y;
1674 int width = static_cast<int>(
1675 region->pRectangles[r].extent.width);
1676 int height = static_cast<int>(
1677 region->pRectangles[r].extent.height);
1678 android_native_rect_t* cur_rect = &rects[r];
1679 cur_rect->left = x;
1680 cur_rect->top = y + height;
1681 cur_rect->right = x + width;
1682 cur_rect->bottom = y;
1683 }
1684 native_window_set_surface_damage(window, rects, rcount);
1685 }
1686 if (time) {
1687 if (!swapchain.frame_timestamps_enabled) {
1688 ALOGV(
1689 "Calling "
1690 "native_window_enable_frame_timestamps(true)");
1691 native_window_enable_frame_timestamps(window, true);
1692 swapchain.frame_timestamps_enabled = true;
1693 }
1694
1695 // Record the nativeFrameId so it can be later correlated to
1696 // this present.
1697 uint64_t nativeFrameId = 0;
1698 err = native_window_get_next_frame_id(
1699 window, &nativeFrameId);
1700 if (err != android::OK) {
1701 ALOGE("Failed to get next native frame ID.");
1702 }
1703
1704 // Add a new timing record with the user's presentID and
1705 // the nativeFrameId.
1706 swapchain.timing.emplace_back(time, nativeFrameId);
1707 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
1708 swapchain.timing.erase(swapchain.timing.begin());
1709 }
1710 if (time->desiredPresentTime) {
1711 // Set the desiredPresentTime:
1712 ALOGV(
1713 "Calling "
1714 "native_window_set_buffers_timestamp(%" PRId64 ")",
1715 time->desiredPresentTime);
1716 native_window_set_buffers_timestamp(
1717 window,
1718 static_cast<int64_t>(time->desiredPresentTime));
1719 }
1720 }
1721
1722 err = window->queueBuffer(window, img.buffer.get(), fence);
1723 // queueBuffer always closes fence, even on error
1724 if (err != android::OK) {
1725 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1726 swapchain_result = WorstPresentResult(
1727 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
1728 } else {
1729 if (img.dequeue_fence >= 0) {
1730 close(img.dequeue_fence);
1731 img.dequeue_fence = -1;
1732 }
1733 img.dequeued = false;
1734 }
1735
1736 // If the swapchain is in shared mode, immediately dequeue the
1737 // buffer so it can be presented again without an intervening
1738 // call to AcquireNextImageKHR. We expect to get the same buffer
1739 // back from every call to dequeueBuffer in this mode.
1740 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
1741 ANativeWindowBuffer* buffer;
1742 int fence_fd;
1743 err = window->dequeueBuffer(window, &buffer, &fence_fd);
1744 if (err != android::OK) {
1745 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1746 swapchain_result = WorstPresentResult(swapchain_result,
1747 VK_ERROR_SURFACE_LOST_KHR);
1748 } else if (img.buffer != buffer) {
1749 ALOGE("got wrong image back for shared swapchain");
1750 swapchain_result = WorstPresentResult(swapchain_result,
1751 VK_ERROR_SURFACE_LOST_KHR);
1752 } else {
1753 img.dequeue_fence = fence_fd;
1754 img.dequeued = true;
1755 }
1756 }
1757 }
1758 if (swapchain_result != VK_SUCCESS) {
1759 OrphanSwapchain(device, &swapchain);
1760 }
1761 int window_transform_hint;
1762 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
1763 &window_transform_hint);
1764 if (err != android::OK) {
1765 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
1766 strerror(-err), err);
1767 swapchain_result = WorstPresentResult(
1768 swapchain_result, VK_ERROR_SURFACE_LOST_KHR);
1769 }
1770 if (swapchain.pre_transform != window_transform_hint) {
1771 swapchain_result =
1772 WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
1773 }
1774 } else {
1775 ReleaseSwapchainImage(device, nullptr, fence, img, true);
1776 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
1777 }
1778
1779 if (present_info->pResults)
1780 present_info->pResults[sc] = swapchain_result;
1781
1782 if (swapchain_result != final_result)
1783 final_result = WorstPresentResult(final_result, swapchain_result);
1784 }
1785 if (rects) {
1786 allocator->pfnFree(allocator->pUserData, rects);
1787 }
1788
1789 return final_result;
1790 }
1791
1792 VKAPI_ATTR
GetRefreshCycleDurationGOOGLE(VkDevice,VkSwapchainKHR swapchain_handle,VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties)1793 VkResult GetRefreshCycleDurationGOOGLE(
1794 VkDevice,
1795 VkSwapchainKHR swapchain_handle,
1796 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
1797 ATRACE_CALL();
1798
1799 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1800 VkResult result = VK_SUCCESS;
1801
1802 pDisplayTimingProperties->refreshDuration = swapchain.get_refresh_duration();
1803
1804 return result;
1805 }
1806
1807 VKAPI_ATTR
GetPastPresentationTimingGOOGLE(VkDevice,VkSwapchainKHR swapchain_handle,uint32_t * count,VkPastPresentationTimingGOOGLE * timings)1808 VkResult GetPastPresentationTimingGOOGLE(
1809 VkDevice,
1810 VkSwapchainKHR swapchain_handle,
1811 uint32_t* count,
1812 VkPastPresentationTimingGOOGLE* timings) {
1813 ATRACE_CALL();
1814
1815 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1816 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1817 return VK_ERROR_OUT_OF_DATE_KHR;
1818 }
1819
1820 ANativeWindow* window = swapchain.surface.window.get();
1821 VkResult result = VK_SUCCESS;
1822
1823 if (!swapchain.frame_timestamps_enabled) {
1824 ALOGV("Calling native_window_enable_frame_timestamps(true)");
1825 native_window_enable_frame_timestamps(window, true);
1826 swapchain.frame_timestamps_enabled = true;
1827 }
1828
1829 if (timings) {
1830 // Get the latest ready timing count before copying, since the copied
1831 // timing info will be erased in copy_ready_timings function.
1832 uint32_t n = get_num_ready_timings(swapchain);
1833 copy_ready_timings(swapchain, count, timings);
1834 // Check the *count here against the recorded ready timing count, since
1835 // *count can be overwritten per spec describes.
1836 if (*count < n) {
1837 result = VK_INCOMPLETE;
1838 }
1839 } else {
1840 *count = get_num_ready_timings(swapchain);
1841 }
1842
1843 return result;
1844 }
1845
1846 VKAPI_ATTR
GetSwapchainStatusKHR(VkDevice,VkSwapchainKHR swapchain_handle)1847 VkResult GetSwapchainStatusKHR(
1848 VkDevice,
1849 VkSwapchainKHR swapchain_handle) {
1850 ATRACE_CALL();
1851
1852 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1853 VkResult result = VK_SUCCESS;
1854
1855 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1856 return VK_ERROR_OUT_OF_DATE_KHR;
1857 }
1858
1859 // TODO(b/143296009): Implement this function properly
1860
1861 return result;
1862 }
1863
SetHdrMetadataEXT(VkDevice,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pHdrMetadataEXTs)1864 VKAPI_ATTR void SetHdrMetadataEXT(
1865 VkDevice,
1866 uint32_t swapchainCount,
1867 const VkSwapchainKHR* pSwapchains,
1868 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
1869 ATRACE_CALL();
1870
1871 for (uint32_t idx = 0; idx < swapchainCount; idx++) {
1872 Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);
1873 if (!swapchain)
1874 continue;
1875
1876 if (swapchain->surface.swapchain_handle != pSwapchains[idx]) continue;
1877
1878 ANativeWindow* window = swapchain->surface.window.get();
1879
1880 VkHdrMetadataEXT vulkanMetadata = pHdrMetadataEXTs[idx];
1881 const android_smpte2086_metadata smpteMetdata = {
1882 {vulkanMetadata.displayPrimaryRed.x,
1883 vulkanMetadata.displayPrimaryRed.y},
1884 {vulkanMetadata.displayPrimaryGreen.x,
1885 vulkanMetadata.displayPrimaryGreen.y},
1886 {vulkanMetadata.displayPrimaryBlue.x,
1887 vulkanMetadata.displayPrimaryBlue.y},
1888 {vulkanMetadata.whitePoint.x, vulkanMetadata.whitePoint.y},
1889 vulkanMetadata.maxLuminance,
1890 vulkanMetadata.minLuminance};
1891 native_window_set_buffers_smpte2086_metadata(window, &smpteMetdata);
1892
1893 const android_cta861_3_metadata cta8613Metadata = {
1894 vulkanMetadata.maxContentLightLevel,
1895 vulkanMetadata.maxFrameAverageLightLevel};
1896 native_window_set_buffers_cta861_3_metadata(window, &cta8613Metadata);
1897 }
1898
1899 return;
1900 }
1901
InterceptBindImageMemory2(uint32_t bind_info_count,const VkBindImageMemoryInfo * bind_infos,std::vector<VkNativeBufferANDROID> * out_native_buffers,std::vector<VkBindImageMemoryInfo> * out_bind_infos)1902 static void InterceptBindImageMemory2(
1903 uint32_t bind_info_count,
1904 const VkBindImageMemoryInfo* bind_infos,
1905 std::vector<VkNativeBufferANDROID>* out_native_buffers,
1906 std::vector<VkBindImageMemoryInfo>* out_bind_infos) {
1907 out_native_buffers->clear();
1908 out_bind_infos->clear();
1909
1910 if (!bind_info_count)
1911 return;
1912
1913 std::unordered_set<uint32_t> intercepted_indexes;
1914
1915 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1916 auto info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1917 bind_infos[idx].pNext);
1918 while (info &&
1919 info->sType !=
1920 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR) {
1921 info = reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(
1922 info->pNext);
1923 }
1924
1925 if (!info)
1926 continue;
1927
1928 ALOG_ASSERT(info->swapchain != VK_NULL_HANDLE,
1929 "swapchain handle must not be NULL");
1930 const Swapchain* swapchain = SwapchainFromHandle(info->swapchain);
1931 ALOG_ASSERT(
1932 info->imageIndex < swapchain->num_images,
1933 "imageIndex must be less than the number of images in swapchain");
1934
1935 ANativeWindowBuffer* buffer =
1936 swapchain->images[info->imageIndex].buffer.get();
1937 VkNativeBufferANDROID native_buffer = {
1938 #pragma clang diagnostic push
1939 #pragma clang diagnostic ignored "-Wold-style-cast"
1940 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1941 #pragma clang diagnostic pop
1942 .pNext = bind_infos[idx].pNext,
1943 .handle = buffer->handle,
1944 .stride = buffer->stride,
1945 .format = buffer->format,
1946 .usage = int(buffer->usage),
1947 };
1948 // Reserve enough space to avoid letting re-allocation invalidate the
1949 // addresses of the elements inside.
1950 out_native_buffers->reserve(bind_info_count);
1951 out_native_buffers->emplace_back(native_buffer);
1952
1953 // Reserve the space now since we know how much is needed now.
1954 out_bind_infos->reserve(bind_info_count);
1955 out_bind_infos->emplace_back(bind_infos[idx]);
1956 out_bind_infos->back().pNext = &out_native_buffers->back();
1957
1958 intercepted_indexes.insert(idx);
1959 }
1960
1961 if (intercepted_indexes.empty())
1962 return;
1963
1964 for (uint32_t idx = 0; idx < bind_info_count; idx++) {
1965 if (intercepted_indexes.count(idx))
1966 continue;
1967 out_bind_infos->emplace_back(bind_infos[idx]);
1968 }
1969 }
1970
1971 VKAPI_ATTR
BindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1972 VkResult BindImageMemory2(VkDevice device,
1973 uint32_t bindInfoCount,
1974 const VkBindImageMemoryInfo* pBindInfos) {
1975 ATRACE_CALL();
1976
1977 // out_native_buffers is for maintaining the lifecycle of the constructed
1978 // VkNativeBufferANDROID objects inside InterceptBindImageMemory2.
1979 std::vector<VkNativeBufferANDROID> out_native_buffers;
1980 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1981 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1982 &out_bind_infos);
1983 return GetData(device).driver.BindImageMemory2(
1984 device, bindInfoCount,
1985 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
1986 }
1987
1988 VKAPI_ATTR
BindImageMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1989 VkResult BindImageMemory2KHR(VkDevice device,
1990 uint32_t bindInfoCount,
1991 const VkBindImageMemoryInfo* pBindInfos) {
1992 ATRACE_CALL();
1993
1994 std::vector<VkNativeBufferANDROID> out_native_buffers;
1995 std::vector<VkBindImageMemoryInfo> out_bind_infos;
1996 InterceptBindImageMemory2(bindInfoCount, pBindInfos, &out_native_buffers,
1997 &out_bind_infos);
1998 return GetData(device).driver.BindImageMemory2KHR(
1999 device, bindInfoCount,
2000 out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
2001 }
2002
2003 } // namespace driver
2004 } // namespace vulkan
2005