blob: f6bdcca62e83f725e7d8f0eb6effe9c2d83f2592 [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
Jesse Halld7b994a2015-09-07 14:17:37 -070017#include <algorithm>
Jesse Halld7b994a2015-09-07 14:17:37 -070018
Mark Salyzyn7823e122016-09-29 08:08:05 -070019#include <log/log.h>
Jesse Halld7b994a2015-09-07 14:17:37 -070020#include <gui/BufferQueue.h>
Jesse Halld7b994a2015-09-07 14:17:37 -070021#include <sync/sync.h>
Chia-I Wue8e689f2016-04-18 08:21:31 +080022#include <utils/StrongPointer.h>
Brian Anderson1049d1d2016-12-16 17:25:57 -080023#include <utils/Vector.h>
Jesse Halld7b994a2015-09-07 14:17:37 -070024
Chia-I Wu4a6a9162016-03-26 07:17:34 +080025#include "driver.h"
Jesse Halld7b994a2015-09-07 14:17:37 -070026
Jesse Hall5ae3abb2015-10-08 14:00:22 -070027// TODO(jessehall): Currently we don't have a good error code for when a native
28// window operation fails. Just returning INITIALIZATION_FAILED for now. Later
29// versions (post SDK 0.9) of the API/extension have a better error code.
30// When updating to that version, audit all error returns.
Chia-I Wu62262232016-03-26 07:06:44 +080031namespace vulkan {
32namespace driver {
Jesse Hall5ae3abb2015-10-08 14:00:22 -070033
Jesse Halld7b994a2015-09-07 14:17:37 -070034namespace {
35
Jesse Hall55bc0972016-02-23 16:43:29 -080036const VkSurfaceTransformFlagsKHR kSupportedTransforms =
37 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
38 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
39 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
40 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
41 // TODO(jessehall): See TODO in TranslateNativeToVulkanTransform.
42 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
43 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
44 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
45 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
46 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
47
48VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
49 // Native and Vulkan transforms are isomorphic, but are represented
50 // differently. Vulkan transforms are built up of an optional horizontal
51 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
52 // transforms are built up from a horizontal flip, vertical flip, and
53 // 90-degree rotation, all optional but always in that order.
54
55 // TODO(jessehall): For now, only support pure rotations, not
56 // flip or flip-and-rotate, until I have more time to test them and build
57 // sample code. As far as I know we never actually use anything besides
58 // pure rotations anyway.
59
60 switch (native) {
61 case 0: // 0x0
62 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
63 // case NATIVE_WINDOW_TRANSFORM_FLIP_H: // 0x1
64 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
65 // case NATIVE_WINDOW_TRANSFORM_FLIP_V: // 0x2
66 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
67 case NATIVE_WINDOW_TRANSFORM_ROT_180: // FLIP_H | FLIP_V
68 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
69 case NATIVE_WINDOW_TRANSFORM_ROT_90: // 0x4
70 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
71 // 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: // FLIP_H | FLIP_V | ROT_90
76 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
Jesse Hall178b6962016-02-24 15:39:50 -080083int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
84 switch (transform) {
85 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
86 return NATIVE_WINDOW_TRANSFORM_ROT_270;
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_90;
91 // TODO(jessehall): See TODO in TranslateNativeToVulkanTransform.
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
Ian Elliott8a977262017-01-19 09:05:58 -0700109class TimingInfo {
110 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800111 TimingInfo() = default;
112 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
Ian Elliott2c6355d2017-01-19 11:02:13 -0700113 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
Brian Anderson1049d1d2016-12-16 17:25:57 -0800114 native_frame_id_(nativeFrameId) {}
115 bool ready() const {
Ian Elliott8a977262017-01-19 09:05:58 -0700116 return (timestamp_desired_present_time_ &&
117 timestamp_actual_present_time_ &&
118 timestamp_render_complete_time_ &&
119 timestamp_composition_latch_time_);
120 }
121 void calculate(uint64_t rdur) {
122 vals_.actualPresentTime = timestamp_actual_present_time_;
123 uint64_t margin = (timestamp_composition_latch_time_ -
124 timestamp_render_complete_time_);
125 // Calculate vals_.earliestPresentTime, and potentially adjust
126 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
127 // is vals_.actualPresentTime. If we can subtract rdur (the duration
128 // of a refresh cycle) from vals_.earliestPresentTime (and also from
129 // vals_.presentMargin) and still leave a positive margin, then we can
130 // report to the application that it could have presented earlier than
131 // it did (per the extension specification). If for some reason, we
132 // can do this subtraction repeatedly, we do, since
133 // vals_.earliestPresentTime really is supposed to be the "earliest".
134 uint64_t early_time = vals_.actualPresentTime;
135 while ((margin > rdur) &&
136 ((early_time - rdur) > timestamp_composition_latch_time_)) {
137 early_time -= rdur;
138 margin -= rdur;
139 }
140 vals_.earliestPresentTime = early_time;
141 vals_.presentMargin = margin;
142 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800143 void get_values(VkPastPresentationTimingGOOGLE* values) const {
144 *values = vals_;
145 }
Ian Elliott8a977262017-01-19 09:05:58 -0700146
147 public:
Brian Anderson1049d1d2016-12-16 17:25:57 -0800148 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700149
Brian Anderson1049d1d2016-12-16 17:25:57 -0800150 uint64_t native_frame_id_ { 0 };
151 uint64_t timestamp_desired_present_time_ { 0 };
152 uint64_t timestamp_actual_present_time_ { 0 };
153 uint64_t timestamp_render_complete_time_ { 0 };
154 uint64_t timestamp_composition_latch_time_ { 0 };
Ian Elliott8a977262017-01-19 09:05:58 -0700155};
156
Jesse Halld7b994a2015-09-07 14:17:37 -0700157// ----------------------------------------------------------------------------
158
Jesse Hall1356b0d2015-11-23 17:24:58 -0800159struct Surface {
Chia-I Wue8e689f2016-04-18 08:21:31 +0800160 android::sp<ANativeWindow> window;
Jesse Halldc225072016-05-30 22:40:14 -0700161 VkSwapchainKHR swapchain_handle;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800162};
163
164VkSurfaceKHR HandleFromSurface(Surface* surface) {
165 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
166}
167
168Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800169 return reinterpret_cast<Surface*>(handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800170}
171
Ian Elliott8a977262017-01-19 09:05:58 -0700172// Maximum number of TimingInfo structs to keep per swapchain:
173enum { MAX_TIMING_INFOS = 10 };
174// Minimum number of frames to look for in the past (so we don't cause
175// syncronous requests to Surface Flinger):
176enum { MIN_NUM_FRAMES_AGO = 5 };
177
Jesse Hall1356b0d2015-11-23 17:24:58 -0800178struct Swapchain {
Ian Elliottffedb652017-02-14 10:58:30 -0700179 Swapchain(Surface& surface_,
180 uint32_t num_images_,
181 VkPresentModeKHR present_mode)
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700182 : surface(surface_),
183 num_images(num_images_),
Ian Elliottffedb652017-02-14 10:58:30 -0700184 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
Ian Elliott8a977262017-01-19 09:05:58 -0700185 frame_timestamps_enabled(false) {
Ian Elliott62c48c92017-01-20 13:13:20 -0700186 ANativeWindow* window = surface.window.get();
Ian Elliottbe833a22017-01-25 13:09:20 -0700187 int64_t rdur;
188 native_window_get_refresh_cycle_duration(
Ian Elliott62c48c92017-01-20 13:13:20 -0700189 window,
Ian Elliottbe833a22017-01-25 13:09:20 -0700190 &rdur);
191 refresh_duration = static_cast<uint64_t>(rdur);
Ian Elliott8a977262017-01-19 09:05:58 -0700192 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800193
194 Surface& surface;
Jesse Halld7b994a2015-09-07 14:17:37 -0700195 uint32_t num_images;
Ian Elliottffedb652017-02-14 10:58:30 -0700196 bool mailbox_mode;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -0700197 bool frame_timestamps_enabled;
Ian Elliottbe833a22017-01-25 13:09:20 -0700198 uint64_t refresh_duration;
Jesse Halld7b994a2015-09-07 14:17:37 -0700199
200 struct Image {
201 Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
202 VkImage image;
Chia-I Wue8e689f2016-04-18 08:21:31 +0800203 android::sp<ANativeWindowBuffer> buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -0700204 // The fence is only valid when the buffer is dequeued, and should be
205 // -1 any other time. When valid, we own the fd, and must ensure it is
206 // closed: either by closing it explicitly when queueing the buffer,
207 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
208 int dequeue_fence;
209 bool dequeued;
210 } images[android::BufferQueue::NUM_BUFFER_SLOTS];
Ian Elliott8a977262017-01-19 09:05:58 -0700211
Brian Anderson1049d1d2016-12-16 17:25:57 -0800212 android::Vector<TimingInfo> timing;
Jesse Halld7b994a2015-09-07 14:17:37 -0700213};
214
215VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
216 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
217}
218
219Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
Jesse Halla3a7a1d2015-11-24 11:37:23 -0800220 return reinterpret_cast<Swapchain*>(handle);
Jesse Halld7b994a2015-09-07 14:17:37 -0700221}
222
Jesse Halldc225072016-05-30 22:40:14 -0700223void ReleaseSwapchainImage(VkDevice device,
224 ANativeWindow* window,
225 int release_fence,
226 Swapchain::Image& image) {
227 ALOG_ASSERT(release_fence == -1 || image.dequeued,
228 "ReleaseSwapchainImage: can't provide a release fence for "
229 "non-dequeued images");
230
231 if (image.dequeued) {
232 if (release_fence >= 0) {
233 // We get here from vkQueuePresentKHR. The application is
234 // responsible for creating an execution dependency chain from
235 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
236 // (release_fence), so we can drop the dequeue_fence here.
237 if (image.dequeue_fence >= 0)
238 close(image.dequeue_fence);
239 } else {
240 // We get here during swapchain destruction, or various serious
241 // error cases e.g. when we can't create the release_fence during
242 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
243 // have already signalled, since the swapchain images are supposed
244 // to be idle before the swapchain is destroyed. In error cases,
245 // there may be rendering in flight to the image, but since we
246 // weren't able to create a release_fence, waiting for the
247 // dequeue_fence is about the best we can do.
248 release_fence = image.dequeue_fence;
249 }
250 image.dequeue_fence = -1;
251
252 if (window) {
253 window->cancelBuffer(window, image.buffer.get(), release_fence);
254 } else {
255 if (release_fence >= 0) {
256 sync_wait(release_fence, -1 /* forever */);
257 close(release_fence);
258 }
259 }
260
261 image.dequeued = false;
262 }
263
264 if (image.image) {
265 GetData(device).driver.DestroyImage(device, image.image, nullptr);
266 image.image = VK_NULL_HANDLE;
267 }
268
269 image.buffer.clear();
270}
271
272void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
273 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
274 return;
Jesse Halldc225072016-05-30 22:40:14 -0700275 for (uint32_t i = 0; i < swapchain->num_images; i++) {
276 if (!swapchain->images[i].dequeued)
277 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i]);
278 }
279 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Ian Elliott8a977262017-01-19 09:05:58 -0700280 swapchain->timing.clear();
281}
282
283uint32_t get_num_ready_timings(Swapchain& swapchain) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800284 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
285 return 0;
286 }
Ian Elliott8a977262017-01-19 09:05:58 -0700287
Brian Anderson1049d1d2016-12-16 17:25:57 -0800288 uint32_t num_ready = 0;
289 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
290 for (uint32_t i = 0; i < num_timings; i++) {
291 TimingInfo& ti = swapchain.timing.editItemAt(i);
292 if (ti.ready()) {
293 // This TimingInfo is ready to be reported to the user. Add it
294 // to the num_ready.
295 num_ready++;
296 continue;
297 }
298 // This TimingInfo is not yet ready to be reported to the user,
299 // and so we should look for any available timestamps that
300 // might make it ready.
301 int64_t desired_present_time = 0;
302 int64_t render_complete_time = 0;
303 int64_t composition_latch_time = 0;
304 int64_t actual_present_time = 0;
305 // Obtain timestamps:
306 int ret = native_window_get_frame_timestamps(
307 swapchain.surface.window.get(), ti.native_frame_id_,
308 &desired_present_time, &render_complete_time,
309 &composition_latch_time,
310 NULL, //&first_composition_start_time,
311 NULL, //&last_composition_start_time,
312 NULL, //&composition_finish_time,
313 // TODO(ianelliott): Maybe ask if this one is
314 // supported, at startup time (since it may not be
315 // supported):
316 &actual_present_time,
317 NULL, //&display_retire_time,
318 NULL, //&dequeue_ready_time,
319 NULL /*&reads_done_time*/);
320
321 if (ret != android::NO_ERROR) {
322 continue;
323 }
324
325 // Record the timestamp(s) we received, and then see if this TimingInfo
326 // is ready to be reported to the user:
327 ti.timestamp_desired_present_time_ =
328 static_cast<uint64_t>(desired_present_time);
329 ti.timestamp_actual_present_time_ =
330 static_cast<uint64_t>(actual_present_time);
331 ti.timestamp_render_complete_time_ =
332 static_cast<uint64_t>(render_complete_time);
333 ti.timestamp_composition_latch_time_ =
334 static_cast<uint64_t>(composition_latch_time);
335
336 if (ti.ready()) {
337 // The TimingInfo has received enough timestamps, and should now
338 // use those timestamps to calculate the info that should be
339 // reported to the user:
340 ti.calculate(swapchain.refresh_duration);
341 num_ready++;
Ian Elliott8a977262017-01-19 09:05:58 -0700342 }
343 }
344 return num_ready;
345}
346
347// TODO(ianelliott): DEAL WITH RETURN VALUE (e.g. VK_INCOMPLETE)!!!
348void copy_ready_timings(Swapchain& swapchain,
349 uint32_t* count,
350 VkPastPresentationTimingGOOGLE* timings) {
Brian Anderson1049d1d2016-12-16 17:25:57 -0800351 if (swapchain.timing.empty()) {
352 *count = 0;
353 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700354 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800355
356 size_t last_ready = swapchain.timing.size() - 1;
357 while (!swapchain.timing[last_ready].ready()) {
358 if (last_ready == 0) {
359 *count = 0;
360 return;
Ian Elliott8a977262017-01-19 09:05:58 -0700361 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800362 last_ready--;
Ian Elliott8a977262017-01-19 09:05:58 -0700363 }
Brian Anderson1049d1d2016-12-16 17:25:57 -0800364
365 uint32_t num_copied = 0;
366 size_t num_to_remove = 0;
367 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
368 const TimingInfo& ti = swapchain.timing[i];
369 if (ti.ready()) {
370 ti.get_values(&timings[num_copied]);
371 num_copied++;
372 }
373 num_to_remove++;
374 }
375
376 // Discard old frames that aren't ready if newer frames are ready.
377 // We don't expect to get the timing info for those old frames.
378 swapchain.timing.removeItemsAt(0, num_to_remove);
379
Ian Elliott8a977262017-01-19 09:05:58 -0700380 *count = num_copied;
Jesse Halldc225072016-05-30 22:40:14 -0700381}
382
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700383android_pixel_format GetNativePixelFormat(VkFormat format) {
384 android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
385 switch (format) {
386 case VK_FORMAT_R8G8B8A8_UNORM:
387 case VK_FORMAT_R8G8B8A8_SRGB:
388 native_format = HAL_PIXEL_FORMAT_RGBA_8888;
389 break;
390 case VK_FORMAT_R5G6B5_UNORM_PACK16:
391 native_format = HAL_PIXEL_FORMAT_RGB_565;
392 break;
393 case VK_FORMAT_R16G16B16A16_SFLOAT:
394 native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
395 break;
396 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
397 native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
398 break;
399 default:
400 ALOGV("unsupported swapchain format %d", format);
401 break;
402 }
403 return native_format;
404}
405
406android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
407 switch (colorspace) {
408 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
409 return HAL_DATASPACE_V0_SRGB;
410 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
411 return HAL_DATASPACE_DISPLAY_P3;
412 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
413 return HAL_DATASPACE_V0_SCRGB_LINEAR;
414 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
415 return HAL_DATASPACE_V0_SCRGB;
416 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
417 return HAL_DATASPACE_DCI_P3_LINEAR;
418 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
419 return HAL_DATASPACE_DCI_P3;
420 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
421 return HAL_DATASPACE_V0_SRGB_LINEAR;
422 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
423 return HAL_DATASPACE_V0_SRGB;
424 case VK_COLOR_SPACE_BT2020_170M_EXT:
425 return static_cast<android_dataspace>(
426 HAL_DATASPACE_STANDARD_BT2020 |
427 HAL_DATASPACE_TRANSFER_SMPTE_170M | HAL_DATASPACE_RANGE_FULL);
428 case VK_COLOR_SPACE_BT2020_ST2084_EXT:
429 return static_cast<android_dataspace>(
430 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
431 HAL_DATASPACE_RANGE_FULL);
432 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
433 return static_cast<android_dataspace>(
434 HAL_DATASPACE_STANDARD_ADOBE_RGB |
435 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
436 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
437 return HAL_DATASPACE_ADOBE_RGB;
438
439 // Pass through is intended to allow app to provide data that is passed
440 // to the display system without modification.
441 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
442 return HAL_DATASPACE_ARBITRARY;
443
444 default:
445 // This indicates that we don't know about the
446 // dataspace specified and we should indicate that
447 // it's unsupported
448 return HAL_DATASPACE_UNKNOWN;
449 }
450}
451
Jesse Halld7b994a2015-09-07 14:17:37 -0700452} // anonymous namespace
Jesse Hallb1352bc2015-09-04 16:12:33 -0700453
Jesse Halle1b12782015-11-30 11:27:32 -0800454VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800455VkResult CreateAndroidSurfaceKHR(
Jesse Hallf9fa9a52016-01-08 16:08:51 -0800456 VkInstance instance,
457 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
458 const VkAllocationCallbacks* allocator,
459 VkSurfaceKHR* out_surface) {
Jesse Hall1f91d392015-12-11 16:28:44 -0800460 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800461 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800462 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
463 alignof(Surface),
464 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800465 if (!mem)
466 return VK_ERROR_OUT_OF_HOST_MEMORY;
467 Surface* surface = new (mem) Surface;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700468
Chia-I Wue8e689f2016-04-18 08:21:31 +0800469 surface->window = pCreateInfo->window;
Jesse Halldc225072016-05-30 22:40:14 -0700470 surface->swapchain_handle = VK_NULL_HANDLE;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700471
Jesse Hall1356b0d2015-11-23 17:24:58 -0800472 // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
473 int err =
474 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
475 if (err != 0) {
476 // TODO(jessehall): Improve error reporting. Can we enumerate possible
477 // errors and translate them to valid Vulkan result codes?
478 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
479 err);
480 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800481 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800482 return VK_ERROR_INITIALIZATION_FAILED;
483 }
Jesse Hallb1352bc2015-09-04 16:12:33 -0700484
Jesse Hall1356b0d2015-11-23 17:24:58 -0800485 *out_surface = HandleFromSurface(surface);
Jesse Hallb1352bc2015-09-04 16:12:33 -0700486 return VK_SUCCESS;
487}
488
Jesse Halle1b12782015-11-30 11:27:32 -0800489VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800490void DestroySurfaceKHR(VkInstance instance,
491 VkSurfaceKHR surface_handle,
492 const VkAllocationCallbacks* allocator) {
Jesse Hall1356b0d2015-11-23 17:24:58 -0800493 Surface* surface = SurfaceFromHandle(surface_handle);
494 if (!surface)
495 return;
496 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700497 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
Jesse Halldc225072016-05-30 22:40:14 -0700498 "destroyed VkSurfaceKHR 0x%" PRIx64
499 " has active VkSwapchainKHR 0x%" PRIx64,
500 reinterpret_cast<uint64_t>(surface_handle),
501 reinterpret_cast<uint64_t>(surface->swapchain_handle));
Jesse Hall1356b0d2015-11-23 17:24:58 -0800502 surface->~Surface();
Jesse Hall1f91d392015-12-11 16:28:44 -0800503 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800504 allocator = &GetData(instance).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800505 allocator->pfnFree(allocator->pUserData, surface);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800506}
507
Jesse Halle1b12782015-11-30 11:27:32 -0800508VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800509VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
510 uint32_t /*queue_family*/,
511 VkSurfaceKHR /*surface*/,
512 VkBool32* supported) {
Jesse Hall0e74f002015-11-30 11:37:59 -0800513 *supported = VK_TRUE;
Jesse Halla6429252015-11-29 18:59:42 -0800514 return VK_SUCCESS;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800515}
516
Jesse Halle1b12782015-11-30 11:27:32 -0800517VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800518VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
Jesse Hallb00daad2015-11-29 19:46:20 -0800519 VkPhysicalDevice /*pdev*/,
520 VkSurfaceKHR surface,
521 VkSurfaceCapabilitiesKHR* capabilities) {
Jesse Halld7b994a2015-09-07 14:17:37 -0700522 int err;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800523 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -0700524
525 int width, height;
526 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
527 if (err != 0) {
528 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
529 strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -0700530 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -0700531 }
532 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
533 if (err != 0) {
534 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
535 strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -0700536 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -0700537 }
538
Jesse Hall55bc0972016-02-23 16:43:29 -0800539 int transform_hint;
540 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
541 if (err != 0) {
542 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
543 strerror(-err), err);
544 return VK_ERROR_INITIALIZATION_FAILED;
545 }
546
Jesse Halld7b994a2015-09-07 14:17:37 -0700547 // TODO(jessehall): Figure out what the min/max values should be.
Jesse Hallb00daad2015-11-29 19:46:20 -0800548 capabilities->minImageCount = 2;
549 capabilities->maxImageCount = 3;
Jesse Halld7b994a2015-09-07 14:17:37 -0700550
Jesse Hallfe2662d2016-02-09 13:26:59 -0800551 capabilities->currentExtent =
552 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
553
Jesse Halld7b994a2015-09-07 14:17:37 -0700554 // TODO(jessehall): Figure out what the max extent should be. Maximum
555 // texture dimension maybe?
Jesse Hallb00daad2015-11-29 19:46:20 -0800556 capabilities->minImageExtent = VkExtent2D{1, 1};
557 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
Jesse Halld7b994a2015-09-07 14:17:37 -0700558
Jesse Hallfe2662d2016-02-09 13:26:59 -0800559 capabilities->maxImageArrayLayers = 1;
560
Jesse Hall55bc0972016-02-23 16:43:29 -0800561 capabilities->supportedTransforms = kSupportedTransforms;
562 capabilities->currentTransform =
563 TranslateNativeToVulkanTransform(transform_hint);
Jesse Halld7b994a2015-09-07 14:17:37 -0700564
Jesse Hallfe2662d2016-02-09 13:26:59 -0800565 // On Android, window composition is a WindowManager property, not something
566 // associated with the bufferqueue. It can't be changed from here.
567 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -0700568
569 // TODO(jessehall): I think these are right, but haven't thought hard about
570 // it. Do we need to query the driver for support of any of these?
571 // Currently not included:
Jesse Halld7b994a2015-09-07 14:17:37 -0700572 // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
573 // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
Jesse Hallb00daad2015-11-29 19:46:20 -0800574 capabilities->supportedUsageFlags =
Jesse Hall3fbc8562015-11-29 22:10:52 -0800575 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
576 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
577 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
Jesse Halld7b994a2015-09-07 14:17:37 -0700578 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
579
Jesse Hallb1352bc2015-09-04 16:12:33 -0700580 return VK_SUCCESS;
581}
582
Jesse Halle1b12782015-11-30 11:27:32 -0800583VKAPI_ATTR
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700584VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
585 VkSurfaceKHR surface_handle,
Chia-I Wu62262232016-03-26 07:06:44 +0800586 uint32_t* count,
587 VkSurfaceFormatKHR* formats) {
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700588 const InstanceData& instance_data = GetData(pdev);
589
Jesse Hall1356b0d2015-11-23 17:24:58 -0800590 // TODO(jessehall): Fill out the set of supported formats. Longer term, add
591 // a new gralloc method to query whether a (format, usage) pair is
592 // supported, and check that for each gralloc format that corresponds to a
593 // Vulkan format. Shorter term, just add a few more formats to the ones
594 // hardcoded below.
Jesse Halld7b994a2015-09-07 14:17:37 -0700595
596 const VkSurfaceFormatKHR kFormats[] = {
Jesse Hall26763382016-05-20 07:13:52 -0700597 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
598 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
599 {VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
Jesse Halld7b994a2015-09-07 14:17:37 -0700600 };
601 const uint32_t kNumFormats = sizeof(kFormats) / sizeof(kFormats[0]);
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700602 uint32_t total_num_formats = kNumFormats;
603
604 bool wide_color_support = false;
605 Surface& surface = *SurfaceFromHandle(surface_handle);
606 int err = native_window_get_wide_color_support(surface.window.get(),
607 &wide_color_support);
608 if (err) {
609 // Not allowed to return a more sensible error code, so do this
610 return VK_ERROR_OUT_OF_HOST_MEMORY;
611 }
612 ALOGV("wide_color_support is: %d", wide_color_support);
613 wide_color_support =
614 wide_color_support &&
615 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
616
617 const VkSurfaceFormatKHR kWideColorFormats[] = {
Courtney Goeltzenleuchterbca34c92017-02-17 11:31:23 -0700618 {VK_FORMAT_R16G16B16A16_SFLOAT,
619 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT},
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700620 {VK_FORMAT_A2R10G10B10_UNORM_PACK32,
621 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT},
622 };
623 const uint32_t kNumWideColorFormats =
624 sizeof(kWideColorFormats) / sizeof(kWideColorFormats[0]);
625 if (wide_color_support) {
626 total_num_formats += kNumWideColorFormats;
627 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700628
629 VkResult result = VK_SUCCESS;
630 if (formats) {
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700631 uint32_t out_count = 0;
632 uint32_t transfer_count = 0;
633 if (*count < total_num_formats)
Jesse Halld7b994a2015-09-07 14:17:37 -0700634 result = VK_INCOMPLETE;
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700635 transfer_count = std::min(*count, kNumFormats);
636 std::copy(kFormats, kFormats + transfer_count, formats);
637 out_count += transfer_count;
638 if (wide_color_support) {
639 transfer_count = std::min(*count - out_count, kNumWideColorFormats);
640 std::copy(kWideColorFormats, kWideColorFormats + transfer_count,
641 formats + out_count);
642 out_count += transfer_count;
643 }
644 *count = out_count;
Jesse Hall7331e222016-09-15 21:26:01 -0700645 } else {
Courtney Goeltzenleuchtere278daf2017-02-02 16:54:57 -0700646 *count = total_num_formats;
Jesse Halld7b994a2015-09-07 14:17:37 -0700647 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700648 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700649}
650
Jesse Halle1b12782015-11-30 11:27:32 -0800651VKAPI_ATTR
Chris Forbese8d79a62017-02-22 12:49:18 +1300652VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
Chia-I Wu62262232016-03-26 07:06:44 +0800653 VkSurfaceKHR /*surface*/,
654 uint32_t* count,
655 VkPresentModeKHR* modes) {
Chris Forbese8d79a62017-02-22 12:49:18 +1300656 android::Vector<VkPresentModeKHR> present_modes;
657 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
658 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
659
660 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
661 if (QueryPresentationProperties(pdev, &present_properties)) {
662 if (present_properties.sharedImage) {
663 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
664 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
665 }
666 }
667
668 uint32_t num_modes = uint32_t(present_modes.size());
Jesse Halld7b994a2015-09-07 14:17:37 -0700669
670 VkResult result = VK_SUCCESS;
671 if (modes) {
Chris Forbese8d79a62017-02-22 12:49:18 +1300672 if (*count < num_modes)
Jesse Halld7b994a2015-09-07 14:17:37 -0700673 result = VK_INCOMPLETE;
Chris Forbese8d79a62017-02-22 12:49:18 +1300674 *count = std::min(*count, num_modes);
675 std::copy(present_modes.begin(), present_modes.begin() + int(*count), modes);
Jesse Hall7331e222016-09-15 21:26:01 -0700676 } else {
Chris Forbese8d79a62017-02-22 12:49:18 +1300677 *count = num_modes;
Jesse Halld7b994a2015-09-07 14:17:37 -0700678 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700679 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -0700680}
681
Jesse Halle1b12782015-11-30 11:27:32 -0800682VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +0800683VkResult CreateSwapchainKHR(VkDevice device,
684 const VkSwapchainCreateInfoKHR* create_info,
685 const VkAllocationCallbacks* allocator,
686 VkSwapchainKHR* swapchain_handle) {
Jesse Halld7b994a2015-09-07 14:17:37 -0700687 int err;
688 VkResult result = VK_SUCCESS;
689
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700690 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
691 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
692 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
693 " oldSwapchain=0x%" PRIx64,
694 reinterpret_cast<uint64_t>(create_info->surface),
695 create_info->minImageCount, create_info->imageFormat,
696 create_info->imageColorSpace, create_info->imageExtent.width,
697 create_info->imageExtent.height, create_info->imageUsage,
698 create_info->preTransform, create_info->presentMode,
699 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
700
Jesse Hall1f91d392015-12-11 16:28:44 -0800701 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800702 allocator = &GetData(device).allocator;
Jesse Hall1f91d392015-12-11 16:28:44 -0800703
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700704 android_pixel_format native_pixel_format =
705 GetNativePixelFormat(create_info->imageFormat);
706 android_dataspace native_dataspace =
707 GetNativeDataspace(create_info->imageColorSpace);
708 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
709 ALOGE(
710 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
711 "failed: Unsupported color space",
712 create_info->imageColorSpace);
713 return VK_ERROR_INITIALIZATION_FAILED;
714 }
715
Jesse Hall42a9eec2016-06-03 12:39:49 -0700716 ALOGV_IF(create_info->imageArrayLayers != 1,
Jesse Halldc225072016-05-30 22:40:14 -0700717 "swapchain imageArrayLayers=%u not supported",
Jesse Hall715b86a2016-01-16 16:34:29 -0800718 create_info->imageArrayLayers);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700719 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
Jesse Halldc225072016-05-30 22:40:14 -0700720 "swapchain preTransform=%#x not supported",
Jesse Hall55bc0972016-02-23 16:43:29 -0800721 create_info->preTransform);
Jesse Hall42a9eec2016-06-03 12:39:49 -0700722 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
Chris Forbes980ad052017-01-18 16:55:07 +1300723 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
Chris Forbes1d5f68c2017-01-31 10:17:01 +1300724 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
725 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
Jesse Halldc225072016-05-30 22:40:14 -0700726 "swapchain presentMode=%u not supported",
Jesse Hall0ae0dce2016-02-09 22:13:34 -0800727 create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -0700728
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700729 Surface& surface = *SurfaceFromHandle(create_info->surface);
730
Jesse Halldc225072016-05-30 22:40:14 -0700731 if (surface.swapchain_handle != create_info->oldSwapchain) {
Jesse Hall42a9eec2016-06-03 12:39:49 -0700732 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
Jesse Halldc225072016-05-30 22:40:14 -0700733 " because it already has active swapchain 0x%" PRIx64
734 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
735 reinterpret_cast<uint64_t>(create_info->surface),
736 reinterpret_cast<uint64_t>(surface.swapchain_handle),
737 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
738 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
739 }
740 if (create_info->oldSwapchain != VK_NULL_HANDLE)
741 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
742
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700743 // -- Reset the native window --
744 // The native window might have been used previously, and had its properties
745 // changed from defaults. That will affect the answer we get for queries
746 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
747 // attempt such queries.
748
Jesse Halldc225072016-05-30 22:40:14 -0700749 // The native window only allows dequeueing all buffers before any have
750 // been queued, since after that point at least one is assumed to be in
751 // non-FREE state at any given time. Disconnecting and re-connecting
752 // orphans the previous buffers, getting us back to the state where we can
753 // dequeue all buffers.
754 err = native_window_api_disconnect(surface.window.get(),
755 NATIVE_WINDOW_API_EGL);
756 ALOGW_IF(err != 0, "native_window_api_disconnect failed: %s (%d)",
757 strerror(-err), err);
758 err =
759 native_window_api_connect(surface.window.get(), NATIVE_WINDOW_API_EGL);
760 ALOGW_IF(err != 0, "native_window_api_connect failed: %s (%d)",
761 strerror(-err), err);
762
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700763 err = native_window_set_buffer_count(surface.window.get(), 0);
764 if (err != 0) {
765 ALOGE("native_window_set_buffer_count(0) failed: %s (%d)",
766 strerror(-err), err);
767 return VK_ERROR_INITIALIZATION_FAILED;
768 }
769
770 err = surface.window->setSwapInterval(surface.window.get(), 1);
771 if (err != 0) {
772 // TODO(jessehall): Improve error reporting. Can we enumerate possible
773 // errors and translate them to valid Vulkan result codes?
774 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
775 strerror(-err), err);
776 return VK_ERROR_INITIALIZATION_FAILED;
777 }
778
Chris Forbesb8042d22017-01-18 18:07:05 +1300779 err = native_window_set_shared_buffer_mode(surface.window.get(), false);
780 if (err != 0) {
781 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
782 strerror(-err), err);
783 return VK_ERROR_INITIALIZATION_FAILED;
784 }
785
786 err = native_window_set_auto_refresh(surface.window.get(), false);
787 if (err != 0) {
788 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
789 strerror(-err), err);
790 return VK_ERROR_INITIALIZATION_FAILED;
791 }
792
Jesse Halld7b994a2015-09-07 14:17:37 -0700793 // -- Configure the native window --
Jesse Halld7b994a2015-09-07 14:17:37 -0700794
Chia-I Wu4a6a9162016-03-26 07:17:34 +0800795 const auto& dispatch = GetData(device).driver;
Jesse Hall70f93352015-11-04 09:41:31 -0800796
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700797 err = native_window_set_buffers_format(surface.window.get(),
798 native_pixel_format);
Jesse Hall517274a2016-02-10 00:07:18 -0800799 if (err != 0) {
800 // TODO(jessehall): Improve error reporting. Can we enumerate possible
801 // errors and translate them to valid Vulkan result codes?
802 ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700803 native_pixel_format, strerror(-err), err);
Jesse Hall517274a2016-02-10 00:07:18 -0800804 return VK_ERROR_INITIALIZATION_FAILED;
805 }
806 err = native_window_set_buffers_data_space(surface.window.get(),
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700807 native_dataspace);
Jesse Hall517274a2016-02-10 00:07:18 -0800808 if (err != 0) {
809 // TODO(jessehall): Improve error reporting. Can we enumerate possible
810 // errors and translate them to valid Vulkan result codes?
811 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
Courtney Goeltzenleuchter7d4a64a2017-02-17 12:59:11 -0700812 native_dataspace, strerror(-err), err);
Jesse Hall517274a2016-02-10 00:07:18 -0800813 return VK_ERROR_INITIALIZATION_FAILED;
814 }
815
Jesse Hall3dd678a2016-01-08 21:52:01 -0800816 err = native_window_set_buffers_dimensions(
817 surface.window.get(), static_cast<int>(create_info->imageExtent.width),
818 static_cast<int>(create_info->imageExtent.height));
Jesse Halld7b994a2015-09-07 14:17:37 -0700819 if (err != 0) {
820 // TODO(jessehall): Improve error reporting. Can we enumerate possible
821 // errors and translate them to valid Vulkan result codes?
822 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
823 create_info->imageExtent.width, create_info->imageExtent.height,
824 strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -0700825 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -0700826 }
827
Jesse Hall178b6962016-02-24 15:39:50 -0800828 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
829 // applied during rendering. native_window_set_transform() expects the
830 // inverse: the transform the app is requesting that the compositor perform
831 // during composition. With native windows, pre-transform works by rendering
832 // with the same transform the compositor is applying (as in Vulkan), but
833 // then requesting the inverse transform, so that when the compositor does
834 // it's job the two transforms cancel each other out and the compositor ends
835 // up applying an identity transform to the app's buffer.
836 err = native_window_set_buffers_transform(
837 surface.window.get(),
838 InvertTransformToNative(create_info->preTransform));
839 if (err != 0) {
840 // TODO(jessehall): Improve error reporting. Can we enumerate possible
841 // errors and translate them to valid Vulkan result codes?
842 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
843 InvertTransformToNative(create_info->preTransform),
844 strerror(-err), err);
845 return VK_ERROR_INITIALIZATION_FAILED;
846 }
847
Jesse Hallf64ca122015-11-03 16:11:10 -0800848 err = native_window_set_scaling_mode(
Jesse Hall1356b0d2015-11-23 17:24:58 -0800849 surface.window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
Jesse Hallf64ca122015-11-03 16:11:10 -0800850 if (err != 0) {
851 // TODO(jessehall): Improve error reporting. Can we enumerate possible
852 // errors and translate them to valid Vulkan result codes?
853 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
854 strerror(-err), err);
Jesse Hallf64ca122015-11-03 16:11:10 -0800855 return VK_ERROR_INITIALIZATION_FAILED;
856 }
857
Jesse Halle6080bf2016-02-28 20:58:50 -0800858 int query_value;
859 err = surface.window->query(surface.window.get(),
860 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
861 &query_value);
862 if (err != 0 || query_value < 0) {
Jesse Halld7b994a2015-09-07 14:17:37 -0700863 // TODO(jessehall): Improve error reporting. Can we enumerate possible
864 // errors and translate them to valid Vulkan result codes?
Jesse Halle6080bf2016-02-28 20:58:50 -0800865 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
866 query_value);
Jesse Hall5ae3abb2015-10-08 14:00:22 -0700867 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -0700868 }
Jesse Halle6080bf2016-02-28 20:58:50 -0800869 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
Jesse Hall0ae0dce2016-02-09 22:13:34 -0800870 // The MIN_UNDEQUEUED_BUFFERS query doesn't know whether we'll be using
871 // async mode or not, and assumes not. But in async mode, the BufferQueue
872 // requires an extra undequeued buffer.
873 // See BufferQueueCore::getMinUndequeuedBufferCountLocked().
874 if (create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR)
875 min_undequeued_buffers += 1;
876
Jesse Halld7b994a2015-09-07 14:17:37 -0700877 uint32_t num_images =
878 (create_info->minImageCount - 1) + min_undequeued_buffers;
Jesse Hall1356b0d2015-11-23 17:24:58 -0800879 err = native_window_set_buffer_count(surface.window.get(), num_images);
Jesse Halld7b994a2015-09-07 14:17:37 -0700880 if (err != 0) {
881 // TODO(jessehall): Improve error reporting. Can we enumerate possible
882 // errors and translate them to valid Vulkan result codes?
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700883 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
884 strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -0700885 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -0700886 }
887
Chris Forbes8c47dc92017-01-12 11:13:58 +1300888 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
Chris Forbes1d5f68c2017-01-31 10:17:01 +1300889 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
890 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Chris Forbes4da65b92017-01-31 11:48:50 +1300891 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
Chris Forbesb8042d22017-01-18 18:07:05 +1300892
893 err = native_window_set_shared_buffer_mode(surface.window.get(), true);
894 if (err != 0) {
895 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
896 return VK_ERROR_INITIALIZATION_FAILED;
897 }
898 }
899
Chris Forbes1d5f68c2017-01-31 10:17:01 +1300900 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
Chris Forbesb8042d22017-01-18 18:07:05 +1300901 err = native_window_set_auto_refresh(surface.window.get(), true);
902 if (err != 0) {
903 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
904 return VK_ERROR_INITIALIZATION_FAILED;
905 }
Chris Forbesb4421522017-01-18 16:57:02 +1300906 }
907
Jesse Hall70f93352015-11-04 09:41:31 -0800908 int gralloc_usage = 0;
Chris Forbes8c47dc92017-01-12 11:13:58 +1300909 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
Jesse Halld1abd742017-02-09 21:45:51 -0800910 uint64_t consumer_usage, producer_usage;
Kalle Raitafc00a1d2017-02-22 13:05:45 -0800911 uint32_t driver_version = GetData(device).driver_version;
912 if (driver_version == 256587285 || driver_version == 96011958) {
Jesse Hall85bb0c52017-02-09 22:13:02 -0800913 // HACK workaround for loader/driver mismatch during transition to
914 // vkGetSwapchainGrallocUsage2ANDROID.
915 typedef VkResult(VKAPI_PTR *
916 PFN_vkGetSwapchainGrallocUsage2ANDROID_HACK)(
917 VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
918 uint64_t * grallocConsumerUsage,
919 uint64_t * grallocProducerUsage);
920 auto get_swapchain_gralloc_usage =
921 reinterpret_cast<PFN_vkGetSwapchainGrallocUsage2ANDROID_HACK>(
922 dispatch.GetSwapchainGrallocUsage2ANDROID);
923 result = get_swapchain_gralloc_usage(
924 device, create_info->imageFormat, create_info->imageUsage,
925 &consumer_usage, &producer_usage);
926 } else {
927 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
928 device, create_info->imageFormat, create_info->imageUsage,
929 swapchain_image_usage, &consumer_usage, &producer_usage);
930 }
Chris Forbes8c47dc92017-01-12 11:13:58 +1300931 if (result != VK_SUCCESS) {
932 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
933 return VK_ERROR_INITIALIZATION_FAILED;
934 }
Jesse Halld1abd742017-02-09 21:45:51 -0800935 // TODO: This is the same translation done by Gralloc1On0Adapter.
936 // Remove it once ANativeWindow has been updated to take gralloc1-style
937 // usages.
938 gralloc_usage =
939 static_cast<int>(consumer_usage) | static_cast<int>(producer_usage);
Chris Forbes8c47dc92017-01-12 11:13:58 +1300940 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
Jesse Hall1f91d392015-12-11 16:28:44 -0800941 result = dispatch.GetSwapchainGrallocUsageANDROID(
Jesse Hallf4ab2b12015-11-30 16:04:55 -0800942 device, create_info->imageFormat, create_info->imageUsage,
Jesse Hall70f93352015-11-04 09:41:31 -0800943 &gralloc_usage);
944 if (result != VK_SUCCESS) {
945 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
Jesse Hall70f93352015-11-04 09:41:31 -0800946 return VK_ERROR_INITIALIZATION_FAILED;
947 }
Jesse Hall70f93352015-11-04 09:41:31 -0800948 }
Jesse Hall1356b0d2015-11-23 17:24:58 -0800949 err = native_window_set_usage(surface.window.get(), gralloc_usage);
Jesse Hall70f93352015-11-04 09:41:31 -0800950 if (err != 0) {
951 // TODO(jessehall): Improve error reporting. Can we enumerate possible
952 // errors and translate them to valid Vulkan result codes?
953 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
Jesse Hall70f93352015-11-04 09:41:31 -0800954 return VK_ERROR_INITIALIZATION_FAILED;
955 }
Jesse Halld7b994a2015-09-07 14:17:37 -0700956
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700957 int swap_interval =
958 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
959 err = surface.window->setSwapInterval(surface.window.get(), swap_interval);
Jesse Hall0ae0dce2016-02-09 22:13:34 -0800960 if (err != 0) {
961 // TODO(jessehall): Improve error reporting. Can we enumerate possible
962 // errors and translate them to valid Vulkan result codes?
Jesse Hall3d1c82a2016-04-22 15:28:29 -0700963 ALOGE("native_window->setSwapInterval(%d) failed: %s (%d)",
964 swap_interval, strerror(-err), err);
Jesse Hall0ae0dce2016-02-09 22:13:34 -0800965 return VK_ERROR_INITIALIZATION_FAILED;
966 }
967
Jesse Halld7b994a2015-09-07 14:17:37 -0700968 // -- Allocate our Swapchain object --
969 // After this point, we must deallocate the swapchain on error.
970
Jesse Hall1f91d392015-12-11 16:28:44 -0800971 void* mem = allocator->pfnAllocation(allocator->pUserData,
972 sizeof(Swapchain), alignof(Swapchain),
973 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
Jesse Hall1356b0d2015-11-23 17:24:58 -0800974 if (!mem)
Jesse Halld7b994a2015-09-07 14:17:37 -0700975 return VK_ERROR_OUT_OF_HOST_MEMORY;
Ian Elliottffedb652017-02-14 10:58:30 -0700976 Swapchain* swapchain =
977 new (mem) Swapchain(surface, num_images, create_info->presentMode);
Jesse Halld7b994a2015-09-07 14:17:37 -0700978
979 // -- Dequeue all buffers and create a VkImage for each --
980 // Any failures during or after this must cancel the dequeued buffers.
981
Chris Forbesb56287a2017-01-12 14:28:58 +1300982 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
983#pragma clang diagnostic push
984#pragma clang diagnostic ignored "-Wold-style-cast"
985 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
986#pragma clang diagnostic pop
987 .pNext = nullptr,
988 .usage = swapchain_image_usage,
989 };
Jesse Halld7b994a2015-09-07 14:17:37 -0700990 VkNativeBufferANDROID image_native_buffer = {
Jesse Halld7b994a2015-09-07 14:17:37 -0700991#pragma clang diagnostic push
992#pragma clang diagnostic ignored "-Wold-style-cast"
993 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
994#pragma clang diagnostic pop
Chris Forbesb56287a2017-01-12 14:28:58 +1300995 .pNext = &swapchain_image_create,
Jesse Halld7b994a2015-09-07 14:17:37 -0700996 };
997 VkImageCreateInfo image_create = {
998 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
999 .pNext = &image_native_buffer,
1000 .imageType = VK_IMAGE_TYPE_2D,
Jesse Hall517274a2016-02-10 00:07:18 -08001001 .format = create_info->imageFormat,
Jesse Halld7b994a2015-09-07 14:17:37 -07001002 .extent = {0, 0, 1},
1003 .mipLevels = 1,
Jesse Halla15a4bf2015-11-19 22:48:02 -08001004 .arrayLayers = 1,
Jesse Hall091ed9e2015-11-30 00:55:29 -08001005 .samples = VK_SAMPLE_COUNT_1_BIT,
Jesse Halld7b994a2015-09-07 14:17:37 -07001006 .tiling = VK_IMAGE_TILING_OPTIMAL,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001007 .usage = create_info->imageUsage,
Jesse Halld7b994a2015-09-07 14:17:37 -07001008 .flags = 0,
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001009 .sharingMode = create_info->imageSharingMode,
Jesse Hall03b6fe12015-11-24 12:44:21 -08001010 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
Jesse Halld7b994a2015-09-07 14:17:37 -07001011 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1012 };
1013
Jesse Halld7b994a2015-09-07 14:17:37 -07001014 for (uint32_t i = 0; i < num_images; i++) {
1015 Swapchain::Image& img = swapchain->images[i];
1016
1017 ANativeWindowBuffer* buffer;
Jesse Hall1356b0d2015-11-23 17:24:58 -08001018 err = surface.window->dequeueBuffer(surface.window.get(), &buffer,
1019 &img.dequeue_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001020 if (err != 0) {
1021 // TODO(jessehall): Improve error reporting. Can we enumerate
1022 // possible errors and translate them to valid Vulkan result codes?
1023 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001024 result = VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -07001025 break;
1026 }
Chia-I Wue8e689f2016-04-18 08:21:31 +08001027 img.buffer = buffer;
Jesse Halld7b994a2015-09-07 14:17:37 -07001028 img.dequeued = true;
1029
1030 image_create.extent =
Jesse Hall3dd678a2016-01-08 21:52:01 -08001031 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1032 static_cast<uint32_t>(img.buffer->height),
1033 1};
Jesse Halld7b994a2015-09-07 14:17:37 -07001034 image_native_buffer.handle = img.buffer->handle;
1035 image_native_buffer.stride = img.buffer->stride;
1036 image_native_buffer.format = img.buffer->format;
1037 image_native_buffer.usage = img.buffer->usage;
Jesse Halld1abd742017-02-09 21:45:51 -08001038 // TODO: Adjust once ANativeWindowBuffer supports gralloc1-style usage.
1039 // For now, this is the same translation Gralloc1On0Adapter does.
1040 image_native_buffer.usage2.consumer =
1041 static_cast<uint64_t>(img.buffer->usage);
1042 image_native_buffer.usage2.producer =
1043 static_cast<uint64_t>(img.buffer->usage);
Jesse Halld7b994a2015-09-07 14:17:37 -07001044
Jesse Hall03b6fe12015-11-24 12:44:21 -08001045 result =
Jesse Hall1f91d392015-12-11 16:28:44 -08001046 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
Jesse Halld7b994a2015-09-07 14:17:37 -07001047 if (result != VK_SUCCESS) {
1048 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1049 break;
1050 }
1051 }
1052
1053 // -- Cancel all buffers, returning them to the queue --
1054 // If an error occurred before, also destroy the VkImage and release the
1055 // buffer reference. Otherwise, we retain a strong reference to the buffer.
1056 //
1057 // TODO(jessehall): The error path here is the same as DestroySwapchain,
1058 // but not the non-error path. Should refactor/unify.
1059 for (uint32_t i = 0; i < num_images; i++) {
1060 Swapchain::Image& img = swapchain->images[i];
1061 if (img.dequeued) {
Jesse Hall1356b0d2015-11-23 17:24:58 -08001062 surface.window->cancelBuffer(surface.window.get(), img.buffer.get(),
1063 img.dequeue_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001064 img.dequeue_fence = -1;
1065 img.dequeued = false;
1066 }
1067 if (result != VK_SUCCESS) {
1068 if (img.image)
Jesse Hall1f91d392015-12-11 16:28:44 -08001069 dispatch.DestroyImage(device, img.image, nullptr);
Jesse Halld7b994a2015-09-07 14:17:37 -07001070 }
1071 }
1072
1073 if (result != VK_SUCCESS) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001074 swapchain->~Swapchain();
Jesse Hall1f91d392015-12-11 16:28:44 -08001075 allocator->pfnFree(allocator->pUserData, swapchain);
Jesse Halld7b994a2015-09-07 14:17:37 -07001076 return result;
1077 }
1078
Jesse Halldc225072016-05-30 22:40:14 -07001079 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1080 *swapchain_handle = surface.swapchain_handle;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001081 return VK_SUCCESS;
1082}
1083
Jesse Halle1b12782015-11-30 11:27:32 -08001084VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001085void DestroySwapchainKHR(VkDevice device,
1086 VkSwapchainKHR swapchain_handle,
1087 const VkAllocationCallbacks* allocator) {
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001088 const auto& dispatch = GetData(device).driver;
Jesse Halld7b994a2015-09-07 14:17:37 -07001089 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
Daniel Kochd78c2e82016-12-13 18:45:13 -05001090 if (!swapchain)
1091 return;
Jesse Hall42a9eec2016-06-03 12:39:49 -07001092 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1093 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
Jesse Halld7b994a2015-09-07 14:17:37 -07001094
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001095 if (swapchain->frame_timestamps_enabled) {
1096 native_window_enable_frame_timestamps(window, false);
1097 }
Jesse Halldc225072016-05-30 22:40:14 -07001098 for (uint32_t i = 0; i < swapchain->num_images; i++)
1099 ReleaseSwapchainImage(device, window, -1, swapchain->images[i]);
Jesse Hall42a9eec2016-06-03 12:39:49 -07001100 if (active)
Jesse Halldc225072016-05-30 22:40:14 -07001101 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
Jesse Hall1f91d392015-12-11 16:28:44 -08001102 if (!allocator)
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001103 allocator = &GetData(device).allocator;
Jesse Halld7b994a2015-09-07 14:17:37 -07001104 swapchain->~Swapchain();
Jesse Hall1f91d392015-12-11 16:28:44 -08001105 allocator->pfnFree(allocator->pUserData, swapchain);
Jesse Hallb1352bc2015-09-04 16:12:33 -07001106}
1107
Jesse Halle1b12782015-11-30 11:27:32 -08001108VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001109VkResult GetSwapchainImagesKHR(VkDevice,
1110 VkSwapchainKHR swapchain_handle,
1111 uint32_t* count,
1112 VkImage* images) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001113 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Halldc225072016-05-30 22:40:14 -07001114 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1115 "getting images for non-active swapchain 0x%" PRIx64
1116 "; only dequeued image handles are valid",
1117 reinterpret_cast<uint64_t>(swapchain_handle));
Jesse Halld7b994a2015-09-07 14:17:37 -07001118 VkResult result = VK_SUCCESS;
1119 if (images) {
1120 uint32_t n = swapchain.num_images;
1121 if (*count < swapchain.num_images) {
1122 n = *count;
1123 result = VK_INCOMPLETE;
1124 }
1125 for (uint32_t i = 0; i < n; i++)
1126 images[i] = swapchain.images[i].image;
Jesse Hall7331e222016-09-15 21:26:01 -07001127 *count = n;
1128 } else {
1129 *count = swapchain.num_images;
Jesse Halld7b994a2015-09-07 14:17:37 -07001130 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001131 return result;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001132}
1133
Jesse Halle1b12782015-11-30 11:27:32 -08001134VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001135VkResult AcquireNextImageKHR(VkDevice device,
1136 VkSwapchainKHR swapchain_handle,
1137 uint64_t timeout,
1138 VkSemaphore semaphore,
1139 VkFence vk_fence,
1140 uint32_t* image_index) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001141 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Jesse Hall1356b0d2015-11-23 17:24:58 -08001142 ANativeWindow* window = swapchain.surface.window.get();
Jesse Halld7b994a2015-09-07 14:17:37 -07001143 VkResult result;
1144 int err;
1145
Jesse Halldc225072016-05-30 22:40:14 -07001146 if (swapchain.surface.swapchain_handle != swapchain_handle)
1147 return VK_ERROR_OUT_OF_DATE_KHR;
1148
Jesse Halld7b994a2015-09-07 14:17:37 -07001149 ALOGW_IF(
1150 timeout != UINT64_MAX,
1151 "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");
1152
1153 ANativeWindowBuffer* buffer;
Jesse Hall06193802015-12-03 16:12:51 -08001154 int fence_fd;
1155 err = window->dequeueBuffer(window, &buffer, &fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001156 if (err != 0) {
1157 // TODO(jessehall): Improve error reporting. Can we enumerate possible
1158 // errors and translate them to valid Vulkan result codes?
1159 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001160 return VK_ERROR_INITIALIZATION_FAILED;
Jesse Halld7b994a2015-09-07 14:17:37 -07001161 }
1162
1163 uint32_t idx;
1164 for (idx = 0; idx < swapchain.num_images; idx++) {
1165 if (swapchain.images[idx].buffer.get() == buffer) {
1166 swapchain.images[idx].dequeued = true;
Jesse Hall06193802015-12-03 16:12:51 -08001167 swapchain.images[idx].dequeue_fence = fence_fd;
Jesse Halld7b994a2015-09-07 14:17:37 -07001168 break;
1169 }
1170 }
1171 if (idx == swapchain.num_images) {
1172 ALOGE("dequeueBuffer returned unrecognized buffer");
Jesse Hall06193802015-12-03 16:12:51 -08001173 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001174 return VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001175 }
1176
1177 int fence_clone = -1;
Jesse Hall06193802015-12-03 16:12:51 -08001178 if (fence_fd != -1) {
1179 fence_clone = dup(fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001180 if (fence_clone == -1) {
1181 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1182 strerror(errno), errno);
Jesse Hall06193802015-12-03 16:12:51 -08001183 sync_wait(fence_fd, -1 /* forever */);
Jesse Halld7b994a2015-09-07 14:17:37 -07001184 }
1185 }
1186
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001187 result = GetData(device).driver.AcquireImageANDROID(
Jesse Hall1f91d392015-12-11 16:28:44 -08001188 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001189 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001190 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1191 // even if the call fails. We could close it ourselves on failure, but
1192 // that would create a race condition if the driver closes it on a
1193 // failure path: some other thread might create an fd with the same
1194 // number between the time the driver closes it and the time we close
1195 // it. We must assume one of: the driver *always* closes it even on
1196 // failure, or *never* closes it on failure.
Jesse Hall06193802015-12-03 16:12:51 -08001197 window->cancelBuffer(window, buffer, fence_fd);
Jesse Halld7b994a2015-09-07 14:17:37 -07001198 swapchain.images[idx].dequeued = false;
1199 swapchain.images[idx].dequeue_fence = -1;
1200 return result;
1201 }
1202
1203 *image_index = idx;
Jesse Hallb1352bc2015-09-04 16:12:33 -07001204 return VK_SUCCESS;
1205}
1206
Jesse Halldc225072016-05-30 22:40:14 -07001207static VkResult WorstPresentResult(VkResult a, VkResult b) {
1208 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1209 // (in spec version 1.0.14).
1210 static const VkResult kWorstToBest[] = {
1211 VK_ERROR_DEVICE_LOST,
1212 VK_ERROR_SURFACE_LOST_KHR,
1213 VK_ERROR_OUT_OF_DATE_KHR,
1214 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1215 VK_ERROR_OUT_OF_HOST_MEMORY,
1216 VK_SUBOPTIMAL_KHR,
1217 };
1218 for (auto result : kWorstToBest) {
1219 if (a == result || b == result)
1220 return result;
1221 }
1222 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1223 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1224 return a != VK_SUCCESS ? a : b;
1225}
1226
Jesse Halle1b12782015-11-30 11:27:32 -08001227VKAPI_ATTR
Chia-I Wu62262232016-03-26 07:06:44 +08001228VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
Jesse Halld7b994a2015-09-07 14:17:37 -07001229 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1230 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1231 present_info->sType);
Jesse Halld7b994a2015-09-07 14:17:37 -07001232
Jesse Halldc225072016-05-30 22:40:14 -07001233 VkDevice device = GetData(queue).driver_device;
Chia-I Wu4a6a9162016-03-26 07:17:34 +08001234 const auto& dispatch = GetData(queue).driver;
Jesse Halld7b994a2015-09-07 14:17:37 -07001235 VkResult final_result = VK_SUCCESS;
Jesse Halldc225072016-05-30 22:40:14 -07001236
Ian Elliottcb351132016-12-13 10:30:40 -07001237 // Look at the pNext chain for supported extension structs:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001238 const VkPresentRegionsKHR* present_regions = nullptr;
1239 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001240 const VkPresentRegionsKHR* next =
1241 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1242 while (next) {
1243 switch (next->sType) {
1244 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1245 present_regions = next;
1246 break;
Ian Elliott14866bb2017-01-20 09:15:48 -07001247 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001248 present_times =
1249 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1250 break;
Ian Elliottcb351132016-12-13 10:30:40 -07001251 default:
1252 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1253 next->sType);
1254 break;
1255 }
1256 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1257 }
1258 ALOGV_IF(
1259 present_regions &&
1260 present_regions->swapchainCount != present_info->swapchainCount,
1261 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001262 ALOGV_IF(present_times &&
1263 present_times->swapchainCount != present_info->swapchainCount,
1264 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1265 "VkPresentInfo::swapchainCount");
Ian Elliottcb351132016-12-13 10:30:40 -07001266 const VkPresentRegionKHR* regions =
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001267 (present_regions) ? present_regions->pRegions : nullptr;
1268 const VkPresentTimeGOOGLE* times =
1269 (present_times) ? present_times->pTimes : nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001270 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001271 android_native_rect_t* rects = nullptr;
Ian Elliottcb351132016-12-13 10:30:40 -07001272 uint32_t nrects = 0;
1273
Jesse Halld7b994a2015-09-07 14:17:37 -07001274 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1275 Swapchain& swapchain =
Jesse Hall03b6fe12015-11-24 12:44:21 -08001276 *SwapchainFromHandle(present_info->pSwapchains[sc]);
Jesse Hallf4ab2b12015-11-30 16:04:55 -08001277 uint32_t image_idx = present_info->pImageIndices[sc];
Jesse Hall5ae3abb2015-10-08 14:00:22 -07001278 Swapchain::Image& img = swapchain.images[image_idx];
Ian Elliottffedb652017-02-14 10:58:30 -07001279 const VkPresentRegionKHR* region =
1280 (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001281 const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
Jesse Halldc225072016-05-30 22:40:14 -07001282 VkResult swapchain_result = VK_SUCCESS;
Jesse Halld7b994a2015-09-07 14:17:37 -07001283 VkResult result;
1284 int err;
1285
Jesse Halld7b994a2015-09-07 14:17:37 -07001286 int fence = -1;
Jesse Hall275d76c2016-01-08 22:39:16 -08001287 result = dispatch.QueueSignalReleaseImageANDROID(
1288 queue, present_info->waitSemaphoreCount,
1289 present_info->pWaitSemaphores, img.image, &fence);
Jesse Halld7b994a2015-09-07 14:17:37 -07001290 if (result != VK_SUCCESS) {
Jesse Hallab9aeef2015-11-04 10:56:20 -08001291 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
Jesse Halldc225072016-05-30 22:40:14 -07001292 swapchain_result = result;
Jesse Halld7b994a2015-09-07 14:17:37 -07001293 }
1294
Jesse Halldc225072016-05-30 22:40:14 -07001295 if (swapchain.surface.swapchain_handle ==
1296 present_info->pSwapchains[sc]) {
1297 ANativeWindow* window = swapchain.surface.window.get();
1298 if (swapchain_result == VK_SUCCESS) {
Ian Elliottcb351132016-12-13 10:30:40 -07001299 if (region) {
1300 // Process the incremental-present hint for this swapchain:
1301 uint32_t rcount = region->rectangleCount;
1302 if (rcount > nrects) {
1303 android_native_rect_t* new_rects =
1304 static_cast<android_native_rect_t*>(
1305 allocator->pfnReallocation(
1306 allocator->pUserData, rects,
1307 sizeof(android_native_rect_t) * rcount,
1308 alignof(android_native_rect_t),
1309 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1310 if (new_rects) {
1311 rects = new_rects;
1312 nrects = rcount;
1313 } else {
1314 rcount = 0; // Ignore the hint for this swapchain
1315 }
1316 }
1317 for (uint32_t r = 0; r < rcount; ++r) {
1318 if (region->pRectangles[r].layer > 0) {
1319 ALOGV(
1320 "vkQueuePresentKHR ignoring invalid layer "
1321 "(%u); using layer 0 instead",
1322 region->pRectangles[r].layer);
1323 }
1324 int x = region->pRectangles[r].offset.x;
1325 int y = region->pRectangles[r].offset.y;
1326 int width = static_cast<int>(
1327 region->pRectangles[r].extent.width);
1328 int height = static_cast<int>(
1329 region->pRectangles[r].extent.height);
1330 android_native_rect_t* cur_rect = &rects[r];
1331 cur_rect->left = x;
1332 cur_rect->top = y + height;
1333 cur_rect->right = x + width;
1334 cur_rect->bottom = y;
1335 }
1336 native_window_set_surface_damage(window, rects, rcount);
1337 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001338 if (time) {
1339 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001340 ALOGV(
1341 "Calling "
1342 "native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001343 native_window_enable_frame_timestamps(window, true);
1344 swapchain.frame_timestamps_enabled = true;
1345 }
Brian Anderson1049d1d2016-12-16 17:25:57 -08001346
1347 // Record the nativeFrameId so it can be later correlated to
1348 // this present.
1349 uint64_t nativeFrameId = 0;
1350 err = native_window_get_next_frame_id(
1351 window, &nativeFrameId);
1352 if (err != android::NO_ERROR) {
1353 ALOGE("Failed to get next native frame ID.");
1354 }
1355
1356 // Add a new timing record with the user's presentID and
1357 // the nativeFrameId.
1358 swapchain.timing.push_back(TimingInfo(time, nativeFrameId));
1359 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
Ian Elliott8a977262017-01-19 09:05:58 -07001360 swapchain.timing.removeAt(0);
1361 }
1362 if (time->desiredPresentTime) {
1363 // Set the desiredPresentTime:
1364 ALOGV(
1365 "Calling "
1366 "native_window_set_buffers_timestamp(%" PRId64 ")",
1367 time->desiredPresentTime);
1368 native_window_set_buffers_timestamp(
1369 window,
1370 static_cast<int64_t>(time->desiredPresentTime));
1371 }
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001372 }
Jesse Halldc225072016-05-30 22:40:14 -07001373 err = window->queueBuffer(window, img.buffer.get(), fence);
1374 // queueBuffer always closes fence, even on error
1375 if (err != 0) {
1376 // TODO(jessehall): What now? We should probably cancel the
1377 // buffer, I guess?
1378 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1379 swapchain_result = WorstPresentResult(
1380 swapchain_result, VK_ERROR_OUT_OF_DATE_KHR);
1381 }
1382 if (img.dequeue_fence >= 0) {
1383 close(img.dequeue_fence);
1384 img.dequeue_fence = -1;
1385 }
1386 img.dequeued = false;
1387 }
1388 if (swapchain_result != VK_SUCCESS) {
1389 ReleaseSwapchainImage(device, window, fence, img);
1390 OrphanSwapchain(device, &swapchain);
1391 }
1392 } else {
1393 ReleaseSwapchainImage(device, nullptr, fence, img);
1394 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
Jesse Halld7b994a2015-09-07 14:17:37 -07001395 }
1396
Jesse Halla9e57032015-11-30 01:03:10 -08001397 if (present_info->pResults)
Jesse Halldc225072016-05-30 22:40:14 -07001398 present_info->pResults[sc] = swapchain_result;
1399
1400 if (swapchain_result != final_result)
1401 final_result = WorstPresentResult(final_result, swapchain_result);
Jesse Halld7b994a2015-09-07 14:17:37 -07001402 }
Ian Elliottcb351132016-12-13 10:30:40 -07001403 if (rects) {
1404 allocator->pfnFree(allocator->pUserData, rects);
1405 }
Jesse Halld7b994a2015-09-07 14:17:37 -07001406
1407 return final_result;
1408}
Jesse Hallb1352bc2015-09-04 16:12:33 -07001409
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001410VKAPI_ATTR
1411VkResult GetRefreshCycleDurationGOOGLE(
1412 VkDevice,
Ian Elliott62c48c92017-01-20 13:13:20 -07001413 VkSwapchainKHR swapchain_handle,
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001414 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
Ian Elliott62c48c92017-01-20 13:13:20 -07001415 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001416 VkResult result = VK_SUCCESS;
1417
Ian Elliottbe833a22017-01-25 13:09:20 -07001418 pDisplayTimingProperties->refreshDuration = swapchain.refresh_duration;
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001419
1420 return result;
1421}
1422
1423VKAPI_ATTR
1424VkResult GetPastPresentationTimingGOOGLE(
1425 VkDevice,
1426 VkSwapchainKHR swapchain_handle,
1427 uint32_t* count,
1428 VkPastPresentationTimingGOOGLE* timings) {
1429 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1430 ANativeWindow* window = swapchain.surface.window.get();
1431 VkResult result = VK_SUCCESS;
1432
1433 if (!swapchain.frame_timestamps_enabled) {
Ian Elliott8a977262017-01-19 09:05:58 -07001434 ALOGV("Calling native_window_enable_frame_timestamps(true)");
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001435 native_window_enable_frame_timestamps(window, true);
1436 swapchain.frame_timestamps_enabled = true;
1437 }
1438
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001439 if (timings) {
Ian Elliott8a977262017-01-19 09:05:58 -07001440 // TODO(ianelliott): plumb return value (e.g. VK_INCOMPLETE)
1441 copy_ready_timings(swapchain, count, timings);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001442 } else {
Ian Elliott8a977262017-01-19 09:05:58 -07001443 *count = get_num_ready_timings(swapchain);
Ian Elliott4c8bb2a2016-12-29 11:07:26 -07001444 }
1445
1446 return result;
1447}
1448
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001449VKAPI_ATTR
1450VkResult GetSwapchainStatusKHR(
1451 VkDevice,
Chris Forbes4e18ba82017-01-20 12:50:17 +13001452 VkSwapchainKHR swapchain_handle) {
1453 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001454 VkResult result = VK_SUCCESS;
1455
Chris Forbes4e18ba82017-01-20 12:50:17 +13001456 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1457 return VK_ERROR_OUT_OF_DATE_KHR;
1458 }
1459
Chris Forbes0f2ac2e2017-01-18 13:33:53 +13001460 // TODO(chrisforbes): Implement this function properly
1461
1462 return result;
1463}
1464
Courtney Goeltzenleuchterd634c482017-01-05 15:55:31 -07001465VKAPI_ATTR void SetHdrMetadataEXT(
1466 VkDevice device,
1467 uint32_t swapchainCount,
1468 const VkSwapchainKHR* pSwapchains,
1469 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
1470 // TODO: courtneygo: implement actual function
1471 (void)device;
1472 (void)swapchainCount;
1473 (void)pSwapchains;
1474 (void)pHdrMetadataEXTs;
1475 return;
1476}
1477
Chia-I Wu62262232016-03-26 07:06:44 +08001478} // namespace driver
Jesse Hallb1352bc2015-09-04 16:12:33 -07001479} // namespace vulkan