Lines Matching defs:chain
961 * the combined status. The chain status will eventually be returned from
969 _x11_swapchain_result(struct x11_swapchain *chain, VkResult result,
973 if (chain->status < 0)
974 return chain->status;
976 /* If we have a new error, mark it as permanent on the chain and return. */
982 chain->status = result;
995 if (chain->status != VK_SUBOPTIMAL_KHR) {
1000 chain->status = result;
1005 return chain->status;
1007 #define x11_swapchain_result(chain, result) \
1008 _x11_swapchain_result(chain, result, __FILE__, __LINE__)
1013 struct x11_swapchain *chain = (struct x11_swapchain *)wsi_chain;
1014 return &chain->images[image_index].base;
1018 * Process an X11 Present event. Does not update chain->status.
1021 x11_handle_dri3_present_event(struct x11_swapchain *chain,
1028 if (config->width != chain->extent.width ||
1029 config->height != chain->extent.height)
1038 for (unsigned i = 0; i < chain->base.image_count; i++) {
1039 if (chain->images[i].pixmap == idle->pixmap) {
1040 chain->images[i].busy = false;
1041 chain->sent_image_count--;
1042 assert(chain->sent_image_count >= 0);
1043 if (chain->has_acquire_queue)
1044 wsi_queue_push(&chain->acquire_queue, i);
1056 for (i = 0; i < chain->base.image_count; i++) {
1057 struct x11_image *image = &chain->images[i];
1061 chain->last_present_msc = complete->msc;
1067 if (chain->copy_is_suboptimal)
1075 chain->copy_is_suboptimal = true;
1114 x11_acquire_next_image_poll_x11(struct x11_swapchain *chain,
1121 for (uint32_t i = 0; i < chain->base.image_count; i++) {
1122 if (!chain->images[i].busy) {
1124 xshmfence_await(chain->images[i].shm_fence);
1126 chain->images[i].busy = true;
1127 return x11_swapchain_result(chain, VK_SUCCESS);
1131 xcb_flush(chain->conn);
1134 event = xcb_wait_for_special_event(chain->conn, chain->special_event);
1136 return x11_swapchain_result(chain, VK_ERROR_SURFACE_LOST_KHR);
1138 event = xcb_poll_for_special_event(chain->conn, chain->special_event);
1142 return x11_swapchain_result(chain, VK_NOT_READY);
1146 pfds.fd = xcb_get_file_descriptor(chain->conn);
1150 return x11_swapchain_result(chain, VK_TIMEOUT);
1152 return x11_swapchain_result(chain, VK_ERROR_OUT_OF_DATE_KHR);
1169 VkResult result = x11_handle_dri3_present_event(chain, (void *)event);
1171 result = x11_swapchain_result(chain, result);
1183 x11_acquire_next_image_from_queue(struct x11_swapchain *chain,
1186 assert(chain->has_acquire_queue);
1189 VkResult result = wsi_queue_pull(&chain->acquire_queue,
1192 /* On error, the thread has shut down, so safe to update chain->status.
1194 * chain->status so that is also safe.
1196 return x11_swapchain_result(chain, result);
1197 } else if (chain->status < 0) {
1198 return chain->status;
1201 assert(image_index < chain->base.image_count);
1202 xshmfence_await(chain->images[image_index].shm_fence);
1206 return chain->status;
1213 x11_present_to_x11_dri3(struct x11_swapchain *chain, uint32_t image_index,
1216 struct x11_image *image = &chain->images[image_index];
1218 assert(image_index < chain->base.image_count);
1226 wsi_x11_get_connection((struct wsi_device*)chain->base.wsi, chain->conn);
1230 if (chain->base.present_mode == VK_PRESENT_MODE_IMMEDIATE_KHR ||
1231 (chain->base.present_mode == VK_PRESENT_MODE_MAILBOX_KHR &&
1233 chain->base.present_mode == VK_PRESENT_MODE_FIFO_RELAXED_KHR)
1237 if (chain->has_dri3_modifiers)
1246 while ((event = xcb_poll_for_special_event(chain->conn, chain->special_event))) {
1247 VkResult result = x11_handle_dri3_present_event(chain, (void *)event);
1249 result = x11_swapchain_result(chain, result);
1257 ++chain->sent_image_count;
1258 assert(chain->sent_image_count <= chain->base.image_count);
1260 ++chain->send_sbc;
1262 image->serial = (uint32_t) chain->send_sbc;
1265 xcb_present_pixmap_checked(chain->conn,
1266 chain->window,
1280 xcb_generic_error_t *error = xcb_request_check(chain->conn, cookie);
1283 return x11_swapchain_result(chain, VK_ERROR_SURFACE_LOST_KHR);
1286 return x11_swapchain_result(chain, VK_SUCCESS);
1293 x11_present_to_x11_sw(struct x11_swapchain *chain, uint32_t image_index,
1296 struct x11_image *image = &chain->images[image_index];
1302 size_t size = (hdr_len + stride_b * chain->extent.height) >> 2;
1303 uint64_t max_req_len = xcb_get_maximum_request_length(chain->conn);
1304 chain->images[image_index].busy = false;
1307 cookie = xcb_put_image(chain->conn, XCB_IMAGE_FORMAT_Z_PIXMAP,
1308 chain->window,
1309 chain->gc,
1311 chain->extent.height,
1313 image->base.row_pitches[0] * chain->extent.height,
1315 xcb_discard_reply(chain->conn, cookie.sequence);
1319 int y_todo = chain->extent.height;
1322 cookie = xcb_put_image(chain->conn, XCB_IMAGE_FORMAT_Z_PIXMAP,
1323 chain->window,
1324 chain->gc,
1330 xcb_discard_reply(chain->conn, cookie.sequence);
1336 xcb_flush(chain->conn);
1337 return x11_swapchain_result(chain, VK_SUCCESS);
1344 x11_present_to_x11(struct x11_swapchain *chain, uint32_t image_index,
1347 if (chain->base.wsi->sw && !chain->has_mit_shm)
1348 return x11_present_to_x11_sw(chain, image_index, target_msc);
1349 return x11_present_to_x11_dri3(chain, image_index, target_msc);
1363 struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain;
1367 if (chain->status < 0)
1368 return chain->status;
1370 if (chain->base.wsi->sw && !chain->has_mit_shm) {
1371 for (unsigned i = 0; i < chain->base.image_count; i++) {
1372 if (!chain->images[i].busy) {
1374 chain->images[i].busy = true;
1377 xcb_get_geometry_cookie_t geom_cookie = xcb_get_geometry(chain->conn, chain->window);
1378 xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(chain->conn, geom_cookie, &err);
1381 if (chain->extent.width != geom->width ||
1382 chain->extent.height != geom->height)
1395 if (chain->has_acquire_queue) {
1396 return x11_acquire_next_image_from_queue(chain, image_index, timeout);
1398 return x11_acquire_next_image_poll_x11(chain, image_index, timeout);
1416 struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain;
1420 if (chain->status < 0)
1421 return chain->status;
1427 update_area = chain->images[image_index].update_region;
1436 xcb_xfixes_set_region(chain->conn, update_area, damage->rectangleCount, rects);
1438 chain->images[image_index].update_area = update_area;
1440 chain->images[image_index].busy = true;
1441 if (chain->has_present_queue) {
1442 wsi_queue_push(&chain->present_queue, image_index);
1443 return chain->status;
1446 return x11_present_to_x11(chain, image_index, 0);
1486 static unsigned x11_driver_owned_images(const struct x11_swapchain *chain)
1488 return chain->base.image_count - chain->sent_image_count;
1509 struct x11_swapchain *chain = state;
1511 wsi_x11_get_connection((struct wsi_device*)chain->base.wsi, chain->conn);
1514 assert(chain->has_present_queue);
1518 while (chain->status >= 0) {
1524 result = wsi_queue_pull(&chain->present_queue, &image_index, INT64_MAX);
1529 } else if (chain->status < 0) {
1539 if (x11_needs_wait_for_fences(chain->base.wsi, wsi_conn,
1540 chain->base.present_mode)) {
1541 result = chain->base.wsi->WaitForFences(chain->base.device, 1,
1542 &chain->base.fences[image_index],
1551 if (chain->has_acquire_queue)
1552 target_msc = chain->last_present_msc + 1;
1554 result = x11_present_to_x11(chain, image_index, target_msc);
1558 if (chain->has_acquire_queue) {
1562 unsigned min_image_count = x11_get_min_image_count(chain->base.wsi);
1566 min_image_count = MIN2(min_image_count, chain->base.image_count);
1578 chain->base.image_count - min_image_count + 1;
1584 while (chain->images[image_index].present_queued ||
1588 x11_driver_owned_images(chain) < forward_progress_guaranteed_acquired_images) {
1591 xcb_wait_for_special_event(chain->conn, chain->special_event);
1597 result = x11_handle_dri3_present_event(chain, (void *)event);
1599 result = x11_swapchain_result(chain, result);
1608 x11_swapchain_result(chain, result);
1609 if (chain->has_acquire_queue)
1610 wsi_queue_push(&chain->acquire_queue, UINT32_MAX);
1639 x11_image_init(VkDevice device_h, struct x11_swapchain *chain,
1649 result = wsi_create_image(&chain->base, &chain->base.image_info,
1654 image->update_region = xcb_generate_id(chain->conn);
1655 xcb_xfixes_create_region(chain->conn, image->update_region, 0, NULL);
1657 if (chain->base.wsi->sw) {
1658 if (!chain->has_mit_shm) {
1663 image->shmseg = xcb_generate_id(chain->conn);
1665 xcb_shm_attach(chain->conn,
1669 image->pixmap = xcb_generate_id(chain->conn);
1670 cookie = xcb_shm_create_pixmap_checked(chain->conn,
1672 chain->window,
1675 chain->depth,
1677 xcb_discard_reply(chain->conn, cookie.sequence);
1680 image->pixmap = xcb_generate_id(chain->conn);
1685 assert(chain->has_dri3_modifiers);
1700 xcb_dri3_pixmap_from_buffers_checked(chain->conn,
1702 chain->window,
1714 chain->depth, bpp,
1729 xcb_dri3_pixmap_from_buffer_checked(chain->conn,
1731 chain->window,
1736 chain->depth, bpp, fd);
1739 xcb_discard_reply(chain->conn, cookie.sequence);
1750 image->sync_fence = xcb_generate_id(chain->conn);
1751 xcb_dri3_fence_from_fd(chain->conn,
1766 cookie = xcb_free_pixmap(chain->conn, image->pixmap);
1767 xcb_discard_reply(chain->conn, cookie.sequence);
1769 wsi_destroy_image(&chain->base, &image->base);
1775 x11_image_finish(struct x11_swapchain *chain,
1781 if (!chain->base.wsi->sw || chain->has_mit_shm) {
1782 cookie = xcb_sync_destroy_fence(chain->conn, image->sync_fence);
1783 xcb_discard_reply(chain->conn, cookie.sequence);
1786 cookie = xcb_free_pixmap(chain->conn, image->pixmap);
1787 xcb_discard_reply(chain->conn, cookie.sequence);
1789 cookie = xcb_xfixes_destroy_region(chain->conn, image->update_region);
1790 xcb_discard_reply(chain->conn, cookie.sequence);
1793 wsi_destroy_image(&chain->base, &image->base);
1881 struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain;
1884 if (chain->has_present_queue) {
1885 chain->status = VK_ERROR_OUT_OF_DATE_KHR;
1887 wsi_queue_push(&chain->present_queue, UINT32_MAX);
1888 pthread_join(chain->queue_manager, NULL);
1890 if (chain->has_acquire_queue)
1891 wsi_queue_destroy(&chain->acquire_queue);
1892 wsi_queue_destroy(&chain->present_queue);
1895 for (uint32_t i = 0; i < chain->base.image_count; i++)
1896 x11_image_finish(chain, pAllocator, &chain->images[i]);
1897 wsi_destroy_image_info(&chain->base, &chain->base.image_info);
1899 xcb_unregister_for_special_event(chain->conn, chain->special_event);
1900 cookie = xcb_present_select_input_checked(chain->conn, chain->event_id,
1901 chain->window,
1903 xcb_discard_reply(chain->conn, cookie.sequence);
1905 wsi_swapchain_finish(&chain->base);
1907 vk_free(pAllocator, chain);
1952 struct x11_swapchain *chain;
1985 * chain's images extents should fit it for performance-optimizing flips.
1997 size_t size = sizeof(*chain) + num_images * sizeof(chain->images[0]);
1998 chain = vk_zalloc(pAllocator, size, 8,
2000 if (chain == NULL)
2011 result = wsi_swapchain_init(wsi_device, &chain->base, device,
2016 chain->base.destroy = x11_swapchain_destroy;
2017 chain->base.get_wsi_image = x11_get_wsi_image;
2018 chain->base.acquire_next_image = x11_acquire_next_image;
2019 chain->base.queue_present = x11_queue_present;
2020 chain->base.present_mode = present_mode;
2021 chain->base.image_count = num_images;
2022 chain->conn = conn;
2023 chain->window = window;
2024 chain->depth = bit_depth;
2025 chain->extent = pCreateInfo->imageExtent;
2026 chain->send_sbc = 0;
2027 chain->sent_image_count = 0;
2028 chain->last_present_msc = 0;
2029 chain->has_acquire_queue = false;
2030 chain->has_present_queue = false;
2031 chain->status = VK_SUCCESS;
2032 chain->has_dri3_modifiers = wsi_conn->has_dri3_modifiers;
2033 chain->has_mit_shm = wsi_conn->has_mit_shm;
2037 * the chain extents X may be able to flip
2039 if (chain->extent.width != cur_width || chain->extent.height != cur_height)
2040 chain->status = VK_SUBOPTIMAL_KHR;
2059 chain->copy_is_suboptimal = false;
2068 chain->event_id = xcb_generate_id(chain->conn);
2069 xcb_present_select_input(chain->conn, chain->event_id, chain->window,
2077 chain->special_event =
2078 xcb_register_for_special_xge(chain->conn, &xcb_present_id,
2079 chain->event_id, NULL);
2082 chain->gc = xcb_generate_id(chain->conn);
2083 if (!chain->gc) {
2089 cookie = xcb_create_gc(chain->conn,
2090 chain->gc,
2091 chain->window,
2094 xcb_discard_reply(chain->conn, cookie.sequence);
2100 wsi_x11_get_dri3_modifiers(wsi_conn, conn, window, chain->depth, 32,
2106 result = wsi_configure_cpu_image(&chain->base, pCreateInfo,
2107 chain->has_mit_shm ? &alloc_shm : NULL,
2108 &chain->base.image_info);
2109 } else if (chain->base.use_buffer_blit) {
2111 result = wsi_configure_prime_image(&chain->base, pCreateInfo,
2113 &chain->base.image_info);
2115 result = wsi_configure_native_image(&chain->base, pCreateInfo,
2118 &chain->base.image_info);
2124 for (; image < chain->base.image_count; image++) {
2125 result = x11_image_init(device, chain, pCreateInfo, pAllocator,
2126 &chain->images[image]);
2142 if ((chain->base.present_mode == VK_PRESENT_MODE_FIFO_KHR ||
2143 chain->base.present_mode == VK_PRESENT_MODE_FIFO_RELAXED_KHR ||
2145 chain->base.present_mode)) &&
2146 !chain->base.wsi->sw) {
2147 chain->has_present_queue = true;
2154 ret = wsi_queue_init(&chain->present_queue, chain->base.image_count + 1);
2159 if (chain->base.present_mode == VK_PRESENT_MODE_FIFO_KHR ||
2160 chain->base.present_mode == VK_PRESENT_MODE_FIFO_RELAXED_KHR) {
2161 chain->has_acquire_queue = true;
2163 ret = wsi_queue_init(&chain->acquire_queue, chain->base.image_count + 1);
2165 wsi_queue_destroy(&chain->present_queue);
2169 for (unsigned i = 0; i < chain->base.image_count; i++)
2170 wsi_queue_push(&chain->acquire_queue, i);
2173 ret = pthread_create(&chain->queue_manager, NULL,
2174 x11_manage_fifo_queues, chain);
2176 wsi_queue_destroy(&chain->present_queue);
2177 if (chain->has_acquire_queue)
2178 wsi_queue_destroy(&chain->acquire_queue);
2184 assert(chain->has_present_queue || !chain->has_acquire_queue);
2195 *swapchain_out = &chain->base;
2201 x11_image_finish(chain, pAllocator, &chain->images[j]);
2203 wsi_destroy_image_info(&chain->base, &chain->base.image_info);
2210 xcb_unregister_for_special_event(chain->conn, chain->special_event);
2212 wsi_swapchain_finish(&chain->base);
2215 vk_free(pAllocator, chain);