mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-10 06:44:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

(Vulkan) Use flags for vulkan_ctx_data

Browse Source
This commit is contained in:
LibretroAdmin 2022-10-30 23:07:07 +01:00
parent 0159c2f70f
commit 724acc4eb9
9 changed files with 105 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
gfx/common/vulkan_common.c
View File

@ -2441,7 +2441,7 @@ static void vulkan_destroy_swapchain(gfx_ctx_vulkan_data_t *vk)
vkDestroySwapchainKHR(vk->context.device, vk->swapchain, NULL); vkDestroySwapchainKHR(vk->context.device, vk->swapchain, NULL);
memset(vk->context.swapchain_images, 0, sizeof(vk->context.swapchain_images)); memset(vk->context.swapchain_images, 0, sizeof(vk->context.swapchain_images));
vk->swapchain = VK_NULL_HANDLE; vk->swapchain = VK_NULL_HANDLE;
vk->context.has_acquired_swapchain = false; vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
} }
for (i = 0; i < VULKAN_MAX_SWAPCHAIN_IMAGES; i++) for (i = 0; i < VULKAN_MAX_SWAPCHAIN_IMAGES; i++)
@ -2729,12 +2729,12 @@ retry:
vk->context.current_frame_index = 0; vk->context.current_frame_index = 0;
vulkan_acquire_clear_fences(vk); vulkan_acquire_clear_fences(vk);
vulkan_acquire_wait_fences(vk); vulkan_acquire_wait_fences(vk);
vk->context.invalid_swapchain = true; vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
return; return;
} }
} }
retro_assert(!vk->context.has_acquired_swapchain); retro_assert(!(vk->context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN));
if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX) if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX)
{ {
@ -2771,7 +2771,7 @@ retry:
{ {
if (fence != VK_NULL_HANDLE) if (fence != VK_NULL_HANDLE)
vkWaitForFences(vk->context.device, 1, &fence, true, UINT64_MAX); vkWaitForFences(vk->context.device, 1, &fence, true, UINT64_MAX);
vk->context.has_acquired_swapchain = true; vk->context.flags |= VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (vk->context.swapchain_acquire_semaphore) if (vk->context.swapchain_acquire_semaphore)
{ {
@ -2788,7 +2788,7 @@ retry:
} }
else else
{ {
vk->context.has_acquired_swapchain = false; vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (semaphore) if (semaphore)
{ {
struct vulkan_context *ctx = &vk->context; struct vulkan_context *ctx = &vk->context;
@ -2834,7 +2834,7 @@ retry:
if (err == VK_ERROR_SURFACE_LOST_KHR) if (err == VK_ERROR_SURFACE_LOST_KHR)
RARCH_ERR("[Vulkan]: Got VK_ERROR_SURFACE_LOST_KHR.\n"); RARCH_ERR("[Vulkan]: Got VK_ERROR_SURFACE_LOST_KHR.\n");
/* Force driver to reset swapchain image handles. */ /* Force driver to reset swapchain image handles. */
vk->context.invalid_swapchain = true; vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
vulkan_acquire_clear_fences(vk); vulkan_acquire_clear_fences(vk);
return; return;
} }
@ -2865,8 +2865,8 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
VkSwapchainCreateInfoKHR info; VkSwapchainCreateInfoKHR info;
VkSurfaceTransformFlagBitsKHR pre_transform; VkSurfaceTransformFlagBitsKHR pre_transform;
VkPresentModeKHR swapchain_present_mode = VK_PRESENT_MODE_FIFO_KHR; VkPresentModeKHR swapchain_present_mode = VK_PRESENT_MODE_FIFO_KHR;
settings_t *settings = config_get_ptr();
VkCompositeAlphaFlagBitsKHR composite = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; VkCompositeAlphaFlagBitsKHR composite = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
settings_t *settings = config_get_ptr();
bool vsync = settings->bools.video_vsync; bool vsync = settings->bools.video_vsync;
vkDeviceWaitIdle(vk->context.device); vkDeviceWaitIdle(vk->context.device);
@ -2890,13 +2890,13 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
else else
vk->flags &= ~VK_DATA_FLAG_EMULATING_MAILBOX; vk->flags &= ~VK_DATA_FLAG_EMULATING_MAILBOX;
vk->flags |= VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN; vk->flags |= VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
if (vk->swapchain != VK_NULL_HANDLE && if ( (vk->swapchain != VK_NULL_HANDLE)
!vk->context.invalid_swapchain && && (!(vk->context.flags & VK_CTX_FLAG_INVALID_SWAPCHAIN))
vk->context.swapchain_width == width && && (vk->context.swapchain_width == width)
vk->context.swapchain_height == height && && (vk->context.swapchain_height == height)
vk->context.swap_interval == swap_interval) && (vk->context.swap_interval == swap_interval))
{ {
/* Do not bother creating a swapchain redundantly. */ /* Do not bother creating a swapchain redundantly. */
#ifdef VULKAN_DEBUG #ifdef VULKAN_DEBUG
@ -2920,7 +2920,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
/* We are tearing down, and entering a state /* We are tearing down, and entering a state
* where we are supposed to have * where we are supposed to have
* acquired an image, so block until we have acquired. */ * acquired an image, so block until we have acquired. */
if (!vk->context.has_acquired_swapchain) if (!(vk->context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
if (vk->mailbox.swapchain != VK_NULL_HANDLE) if (vk->mailbox.swapchain != VK_NULL_HANDLE)
res = vulkan_emulated_mailbox_acquire_next_image_blocking( res = vulkan_emulated_mailbox_acquire_next_image_blocking(
&vk->mailbox, &vk->mailbox,
@ -2930,13 +2930,13 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
if (res == VK_SUCCESS) if (res == VK_SUCCESS)
{ {
vk->context.has_acquired_swapchain = true; vk->context.flags |= VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
vk->flags &= ~VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN; vk->flags &= ~VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
return true; return true;
} }
/* We failed for some reason, so create a new swapchain. */ /* We failed for some reason, so create a new swapchain. */
vk->context.has_acquired_swapchain = false; vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
} }
else else
{ {
@ -3015,7 +3015,10 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
} }
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
vk->context.hdr_enable = settings->bools.video_hdr_enable; if (settings->bools.video_hdr_enable)
vk->context.flags |= VK_CTX_FLAG_HDR_ENABLE;
else
vk->context.flags &= ~VK_CTX_FLAG_HDR_ENABLE;
video_driver_unset_hdr_support(); video_driver_unset_hdr_support();
@ -3028,10 +3031,11 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
} }
} }
if (!vk->context.hdr_enable || format.format == VK_FORMAT_UNDEFINED) if ( (!(vk->context.flags & VK_CTX_FLAG_HDR_ENABLE))
vk->context.hdr_enable = false; || (format.format == VK_FORMAT_UNDEFINED))
vk->context.flags &= ~VK_CTX_FLAG_HDR_ENABLE;
if (!vk->context.hdr_enable) if (!(vk->context.flags & VK_CTX_FLAG_HDR_ENABLE))
#endif /* VULKAN_HDR_SWAPCHAIN */ #endif /* VULKAN_HDR_SWAPCHAIN */
{ {
for (i = 0; i < format_count; i++) for (i = 0; i < format_count; i++)
@ -3180,22 +3184,22 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
{ {
case VK_FORMAT_B8G8R8A8_SRGB: case VK_FORMAT_B8G8R8A8_SRGB:
vk->context.swapchain_format = VK_FORMAT_B8G8R8A8_UNORM; vk->context.swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
vk->context.swapchain_is_srgb = true; vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break; break;
case VK_FORMAT_R8G8B8A8_SRGB: case VK_FORMAT_R8G8B8A8_SRGB:
vk->context.swapchain_format = VK_FORMAT_R8G8B8A8_UNORM; vk->context.swapchain_format = VK_FORMAT_R8G8B8A8_UNORM;
vk->context.swapchain_is_srgb = true; vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break; break;
case VK_FORMAT_R8G8B8_SRGB: case VK_FORMAT_R8G8B8_SRGB:
vk->context.swapchain_format = VK_FORMAT_R8G8B8_UNORM; vk->context.swapchain_format = VK_FORMAT_R8G8B8_UNORM;
vk->context.swapchain_is_srgb = true; vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break; break;
case VK_FORMAT_B8G8R8_SRGB: case VK_FORMAT_B8G8R8_SRGB:
vk->context.swapchain_format = VK_FORMAT_B8G8R8_UNORM; vk->context.swapchain_format = VK_FORMAT_B8G8R8_UNORM;
vk->context.swapchain_is_srgb = true; vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break; break;
default: default:
@ -3213,8 +3217,8 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
vk->context.num_swapchain_images); vk->context.num_swapchain_images);
/* Force driver to reset swapchain image handles. */ /* Force driver to reset swapchain image handles. */
vk->context.invalid_swapchain = true; vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
vk->context.has_acquired_swapchain = false; vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
vulkan_create_wait_fences(vk); vulkan_create_wait_fences(vk);
if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX) if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX)

22
gfx/common/vulkan_common.h
View File

@ -114,6 +114,16 @@ typedef struct ALIGN(16)
} vulkan_hdr_uniform_t; } vulkan_hdr_uniform_t;
#endif /* VULKAN_HDR_SWAPCHAIN */ #endif /* VULKAN_HDR_SWAPCHAIN */
enum vulkan_context_flags
{
VK_CTX_FLAG_INVALID_SWAPCHAIN = (1 << 0),
VK_CTX_FLAG_HDR_ENABLE = (1 << 1),
/* Used by screenshot to get blits with correct colorspace. */
VK_CTX_FLAG_SWAPCHAIN_IS_SRGB = (1 << 2),
VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK = (1 << 3),
VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN = (1 << 4)
};
typedef struct vulkan_context typedef struct vulkan_context
{ {
slock_t *queue_lock; slock_t *queue_lock;
@ -152,17 +162,9 @@ typedef struct vulkan_context
unsigned swap_interval; unsigned swap_interval;
unsigned num_recycled_acquire_semaphores; unsigned num_recycled_acquire_semaphores;
bool swapchain_fences_signalled[VULKAN_MAX_SWAPCHAIN_IMAGES]; uint8_t flags;
bool invalid_swapchain;
/* Used by screenshot to get blits with correct colorspace. */
bool swapchain_is_srgb;
bool swap_interval_emulation_lock;
bool has_acquired_swapchain;
#ifdef VULKAN_HDR_SWAPCHAIN
bool hdr_enable;
#endif /* VULKAN_HDR_SWAPCHAIN */
bool swapchain_fences_signalled[VULKAN_MAX_SWAPCHAIN_IMAGES];
} vulkan_context_t; } vulkan_context_t;
enum vulkan_emulated_mailbox_flags enum vulkan_emulated_mailbox_flags

77
gfx/drivers/vulkan.c
View File

@ -929,7 +929,7 @@ static bool vulkan_init_default_filter_chain(vk_t *vk)
} }
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
if (vk->context->hdr_enable) if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{ {
struct video_shader* shader_preset = vulkan_filter_chain_get_preset( struct video_shader* shader_preset = vulkan_filter_chain_get_preset(
vk->filter_chain); vk->filter_chain);
@ -997,7 +997,7 @@ static bool vulkan_init_filter_chain_preset(vk_t *vk, const char *shader_path)
} }
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
if (vk->context->hdr_enable) if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{ {
struct video_shader* shader_preset = vulkan_filter_chain_get_preset(vk->filter_chain); struct video_shader* shader_preset = vulkan_filter_chain_get_preset(vk->filter_chain);
VkFormat rt_format = (shader_preset && shader_preset->passes) ? vulkan_filter_chain_get_pass_rt_format(vk->filter_chain, shader_preset->passes - 1) : VK_FORMAT_UNDEFINED; VkFormat rt_format = (shader_preset && shader_preset->passes) ? vulkan_filter_chain_get_pass_rt_format(vk->filter_chain, shader_preset->passes - 1) : VK_FORMAT_UNDEFINED;
@ -1656,7 +1656,7 @@ static void vulkan_check_swapchain(vk_t *vk)
&info, &vk->swapchain[i].cmd); &info, &vk->swapchain[i].cmd);
} }
} }
vk->context->invalid_swapchain = false; vk->context->flags &= ~VK_CTX_FLAG_INVALID_SWAPCHAIN;
filter_info.viewport = vk->vk_vp; filter_info.viewport = vk->vk_vp;
filter_info.format = vk->context->swapchain_format; filter_info.format = vk->context->swapchain_format;
@ -1691,7 +1691,7 @@ static void vulkan_set_nonblock_state(void *data, bool state,
/* Changing vsync might require recreating the swapchain, /* Changing vsync might require recreating the swapchain,
* which means new VkImages to render into. */ * which means new VkImages to render into. */
if (vk->context->invalid_swapchain) if (vk->context->flags & VK_CTX_FLAG_INVALID_SWAPCHAIN)
vulkan_check_swapchain(vk); vulkan_check_swapchain(vk);
} }
@ -2019,15 +2019,16 @@ static void vulkan_inject_black_frame(vk_t *vk, video_frame_info_t *video_info)
submit_info.commandBufferCount = 1; submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &vk->cmd; submit_info.pCommandBuffers = &vk->cmd;
if ( if (
vk->context->has_acquired_swapchain (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& vk->context->swapchain_semaphores[swapchain_index] != VK_NULL_HANDLE) && (vk->context->swapchain_semaphores[swapchain_index] !=
VK_NULL_HANDLE))
{ {
submit_info.signalSemaphoreCount = 1; submit_info.signalSemaphoreCount = 1;
submit_info.pSignalSemaphores = &vk->context->swapchain_semaphores[swapchain_index]; submit_info.pSignalSemaphores = &vk->context->swapchain_semaphores[swapchain_index];
} }
if ( vk->context->has_acquired_swapchain if ( (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE) && (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{ {
static const VkPipelineStageFlags wait_stage = static const VkPipelineStageFlags wait_stage =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@ -2090,8 +2091,9 @@ static bool vulkan_frame(void *data, const void *frame,
bool overlay_behind_menu = video_info->overlay_behind_menu; bool overlay_behind_menu = video_info->overlay_behind_menu;
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
bool use_main_buffer = vk->context->hdr_enable && bool use_main_buffer = (vk->context->flags &
(!vk->filter_chain || !vulkan_filter_chain_emits_hdr10(vk->filter_chain)); VK_CTX_FLAG_HDR_ENABLE)
&& (!vk->filter_chain || !vulkan_filter_chain_emits_hdr10(vk->filter_chain));
#endif /* VULKAN_HDR_SWAPCHAIN */ #endif /* VULKAN_HDR_SWAPCHAIN */
/* Bookkeeping on start of frame. */ /* Bookkeeping on start of frame. */
@ -2335,7 +2337,7 @@ static bool vulkan_frame(void *data, const void *frame,
/* Render to backbuffer. */ /* Render to backbuffer. */
if ( (backbuffer->image != VK_NULL_HANDLE) if ( (backbuffer->image != VK_NULL_HANDLE)
&& vk->context->has_acquired_swapchain) && (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
{ {
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_info.pNext = NULL; rp_info.pNext = NULL;
@ -2579,8 +2581,8 @@ static bool vulkan_frame(void *data, const void *frame,
vulkan_filter_chain_end_frame((vulkan_filter_chain_t*)vk->filter_chain, vk->cmd); vulkan_filter_chain_end_frame((vulkan_filter_chain_t*)vk->filter_chain, vk->cmd);
if ( if (
backbuffer->image != VK_NULL_HANDLE (backbuffer->image != VK_NULL_HANDLE)
&& vk->context->has_acquired_swapchain && (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
) )
{ {
if (vk->readback.pending || vk->readback.streamed) if (vk->readback.pending || vk->readback.streamed)
@ -2679,8 +2681,8 @@ static bool vulkan_frame(void *data, const void *frame,
vk->hw.valid_semaphore = false; vk->hw.valid_semaphore = false;
/* We allocated space for this. */ /* We allocated space for this. */
if (vk->context->has_acquired_swapchain && if ( (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE) && (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{ {
assert(!vk->context->swapchain_wait_semaphores[frame_index]); assert(!vk->context->swapchain_wait_semaphores[frame_index]);
vk->context->swapchain_wait_semaphores[frame_index] = vk->context->swapchain_wait_semaphores[frame_index] =
@ -2692,8 +2694,8 @@ static bool vulkan_frame(void *data, const void *frame,
submit_info.waitSemaphoreCount++; submit_info.waitSemaphoreCount++;
} }
} }
else if (vk->context->has_acquired_swapchain && else if ((vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE) && (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{ {
static const VkPipelineStageFlags wait_stage = static const VkPipelineStageFlags wait_stage =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@ -2716,9 +2718,9 @@ static bool vulkan_frame(void *data, const void *frame,
submit_info.signalSemaphoreCount = 0; submit_info.signalSemaphoreCount = 0;
if (vk->context->swapchain_semaphores[swapchain_index] if ((vk->context->swapchain_semaphores[swapchain_index]
!= VK_NULL_HANDLE && != VK_NULL_HANDLE)
vk->context->has_acquired_swapchain) && (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
signal_semaphores[submit_info.signalSemaphoreCount++] = vk->context->swapchain_semaphores[swapchain_index]; signal_semaphores[submit_info.signalSemaphoreCount++] = vk->context->swapchain_semaphores[swapchain_index];
if (vk->hw.signal_semaphore != VK_NULL_HANDLE) if (vk->hw.signal_semaphore != VK_NULL_HANDLE)
@ -2741,7 +2743,7 @@ static bool vulkan_frame(void *data, const void *frame,
if (vk->ctx_driver->swap_buffers) if (vk->ctx_driver->swap_buffers)
vk->ctx_driver->swap_buffers(vk->ctx_data); vk->ctx_driver->swap_buffers(vk->ctx_data);
if (!vk->context->swap_interval_emulation_lock) if (!(vk->context->flags & VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK))
{ {
if (vk->ctx_driver->update_window_title) if (vk->ctx_driver->update_window_title)
vk->ctx_driver->update_window_title(vk->ctx_data); vk->ctx_driver->update_window_title(vk->ctx_data);
@ -2751,16 +2753,17 @@ static bool vulkan_frame(void *data, const void *frame,
* i.e. right after swap buffers. */ * i.e. right after swap buffers. */
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
bool video_hdr_enable = video_info->hdr_enable; bool video_hdr_enable = video_info->hdr_enable;
if (vk->should_resize || (vk->context->hdr_enable != video_hdr_enable)) if ( vk->should_resize
|| (((vk->context->flags & VK_CTX_FLAG_HDR_ENABLE) > 0)
!= video_hdr_enable))
#else #else
if (vk->should_resize) if (vk->should_resize)
#endif /* VULKAN_HDR_SWAPCHAIN */ #endif /* VULKAN_HDR_SWAPCHAIN */
{ {
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
vk->context->hdr_enable = video_hdr_enable; if (video_hdr_enable)
if (vk->context->hdr_enable)
{ {
vk->context->flags |= VK_CTX_FLAG_HDR_ENABLE;
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
slock_lock(vk->context->queue_lock); slock_lock(vk->context->queue_lock);
#endif #endif
@ -2768,9 +2771,11 @@ static bool vulkan_frame(void *data, const void *frame,
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
slock_unlock(vk->context->queue_lock); slock_unlock(vk->context->queue_lock);
#endif #endif
vulkan_destroy_hdr_buffer(vk->context->device, &vk->main_buffer); vulkan_destroy_hdr_buffer(vk->context->device, &vk->main_buffer);
} }
else
vk->context->flags &= ~VK_CTX_FLAG_HDR_ENABLE;
#endif /* VULKAN_HDR_SWAPCHAIN */ #endif /* VULKAN_HDR_SWAPCHAIN */
gfx_ctx_mode_t mode; gfx_ctx_mode_t mode;
@ -2782,9 +2787,9 @@ static bool vulkan_frame(void *data, const void *frame,
#ifdef VULKAN_HDR_SWAPCHAIN #ifdef VULKAN_HDR_SWAPCHAIN
if (!(vk->hdr.support = vk->context->swapchain_colour_space == VK_COLOR_SPACE_HDR10_ST2084_EXT)) if (!(vk->hdr.support = vk->context->swapchain_colour_space == VK_COLOR_SPACE_HDR10_ST2084_EXT))
vk->context->hdr_enable = false; vk->context->flags &= ~VK_CTX_FLAG_HDR_ENABLE;
if (vk->context->hdr_enable) if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{ {
VkMemoryRequirements mem_reqs; VkMemoryRequirements mem_reqs;
VkImageCreateInfo image_info; VkImageCreateInfo image_info;
@ -2869,14 +2874,14 @@ static bool vulkan_frame(void *data, const void *frame,
vk->should_resize = false; vk->should_resize = false;
} }
if (vk->context->invalid_swapchain) if (vk->context->flags & VK_CTX_FLAG_INVALID_SWAPCHAIN)
vulkan_check_swapchain(vk); vulkan_check_swapchain(vk);
/* Disable BFI during fast forward, slow-motion, /* Disable BFI during fast forward, slow-motion,
* and pause to prevent flicker. */ * and pause to prevent flicker. */
if ( if (
backbuffer->image != VK_NULL_HANDLE (backbuffer->image != VK_NULL_HANDLE)
&& vk->context->has_acquired_swapchain && (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& black_frame_insertion && black_frame_insertion
&& !input_driver_nonblock_state && !input_driver_nonblock_state
&& !runloop_is_slowmotion && !runloop_is_slowmotion
@ -2896,21 +2901,21 @@ static bool vulkan_frame(void *data, const void *frame,
/* Vulkan doesn't directly support swap_interval > 1, /* Vulkan doesn't directly support swap_interval > 1,
* so we fake it by duping out more frames. */ * so we fake it by duping out more frames. */
if ( vk->context->swap_interval > 1 if ( (vk->context->swap_interval > 1)
&& !vk->context->swap_interval_emulation_lock) && (!(vk->context->flags & VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK)))
{ {
unsigned i; unsigned i;
vk->context->swap_interval_emulation_lock = true; vk->context->flags |= VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
for (i = 1; i < vk->context->swap_interval; i++) for (i = 1; i < vk->context->swap_interval; i++)
{ {
if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg, if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg,
video_info)) video_info))
{ {
vk->context->swap_interval_emulation_lock = false; vk->context->flags &= ~VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
return false; return false;
} }
} }
vk->context->swap_interval_emulation_lock = false; vk->context->flags &= ~VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
} }
return true; return true;

6
gfx/drivers_context/android_vk_ctx.c
View File

@ -145,7 +145,7 @@ static bool android_gfx_ctx_vk_set_resize(void *data,
if (and->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (and->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&and->vk); vulkan_acquire_next_image(&and->vk);
and->vk.context.invalid_swapchain = true; and->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
and->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN; and->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true; return true;
@ -254,9 +254,9 @@ static void android_gfx_ctx_vk_swap_buffers(void *data)
{ {
android_ctx_data_vk_t *and = (android_ctx_data_vk_t*)data; android_ctx_data_vk_t *and = (android_ctx_data_vk_t*)data;
if (and->vk.context.has_acquired_swapchain) if (and->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
and->vk.context.has_acquired_swapchain = false; and->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (and->vk.swapchain == VK_NULL_HANDLE) if (and->vk.swapchain == VK_NULL_HANDLE)
{ {
retro_sleep(10); retro_sleep(10);

6
gfx/drivers_context/cocoa_vk_ctx.m
View File

@ -178,9 +178,9 @@ static void cocoa_vk_gfx_ctx_swap_buffers(void *data)
{ {
cocoa_ctx_data_t *cocoa_ctx = (cocoa_ctx_data_t*)data; cocoa_ctx_data_t *cocoa_ctx = (cocoa_ctx_data_t*)data;
if (cocoa_ctx->vk.context.has_acquired_swapchain) if (cocoa_ctx->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
cocoa_ctx->vk.context.has_acquired_swapchain = false; cocoa_ctx->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (cocoa_ctx->vk.swapchain == VK_NULL_HANDLE) if (cocoa_ctx->vk.swapchain == VK_NULL_HANDLE)
{ {
retro_sleep(10); retro_sleep(10);
@ -320,7 +320,7 @@ static bool cocoa_vk_gfx_ctx_set_resize(void *data, unsigned width, unsigned hei
return false; return false;
} }
cocoa_ctx->vk.context.invalid_swapchain = true; cocoa_ctx->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
if (cocoa_ctx->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (cocoa_ctx->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&cocoa_ctx->vk); vulkan_acquire_next_image(&cocoa_ctx->vk);

8
gfx/drivers_context/khr_display_ctx.c
View File

@ -115,8 +115,8 @@ static bool gfx_ctx_khr_display_set_resize(void *data,
if (khr->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (khr->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&khr->vk); vulkan_acquire_next_image(&khr->vk);
khr->vk.context.invalid_swapchain = true; khr->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
khr->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN; khr->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true; return true;
} }
@ -231,9 +231,9 @@ static void gfx_ctx_khr_display_set_swap_interval(void *data,
static void gfx_ctx_khr_display_swap_buffers(void *data) static void gfx_ctx_khr_display_swap_buffers(void *data)
{ {
khr_display_ctx_data_t *khr = (khr_display_ctx_data_t*)data; khr_display_ctx_data_t *khr = (khr_display_ctx_data_t*)data;
if (khr->vk.context.has_acquired_swapchain) if (khr->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
khr->vk.context.has_acquired_swapchain = false; khr->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (khr->vk.swapchain == VK_NULL_HANDLE) if (khr->vk.swapchain == VK_NULL_HANDLE)
{ {
retro_sleep(10); retro_sleep(10);

6
gfx/drivers_context/w_vk_ctx.c
View File

@ -125,9 +125,9 @@ static void gfx_ctx_w_vk_check_window(void *data, bool *quit,
static void gfx_ctx_w_vk_swap_buffers(void *data) static void gfx_ctx_w_vk_swap_buffers(void *data)
{ {
if (win32_vk.context.has_acquired_swapchain) if (win32_vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
win32_vk.context.has_acquired_swapchain = false; win32_vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
/* We're still waiting for a proper swapchain, so just fake it. */ /* We're still waiting for a proper swapchain, so just fake it. */
if (win32_vk.swapchain == VK_NULL_HANDLE) if (win32_vk.swapchain == VK_NULL_HANDLE)
retro_sleep(10); retro_sleep(10);
@ -144,7 +144,7 @@ static bool gfx_ctx_w_vk_set_resize(void *data,
{ {
if (win32_vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (win32_vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&win32_vk); vulkan_acquire_next_image(&win32_vk);
win32_vk.context.invalid_swapchain = true; win32_vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
win32_vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN; win32_vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true; return true;

8
gfx/drivers_context/wayland_vk_ctx.c
View File

@ -95,11 +95,11 @@ static bool gfx_ctx_wl_set_resize(void *data, unsigned width, unsigned height)
if (vulkan_create_swapchain(&wl->vk, width, height, wl->swap_interval)) if (vulkan_create_swapchain(&wl->vk, width, height, wl->swap_interval))
{ {
wl->vk.context.invalid_swapchain = true; wl->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
if (wl->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (wl->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&wl->vk); vulkan_acquire_next_image(&wl->vk);
wl->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN; wl->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
wl_surface_set_buffer_scale(wl->surface, wl->buffer_scale); wl_surface_set_buffer_scale(wl->surface, wl->buffer_scale);
@ -273,9 +273,9 @@ static void gfx_ctx_wl_swap_buffers(void *data)
{ {
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data; gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (wl->vk.context.has_acquired_swapchain) if (wl->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
wl->vk.context.has_acquired_swapchain = false; wl->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (wl->vk.swapchain == VK_NULL_HANDLE) if (wl->vk.swapchain == VK_NULL_HANDLE)
{ {
retro_sleep(10); retro_sleep(10);

8
gfx/drivers_context/x_vk_ctx.c
View File

@ -149,9 +149,9 @@ static void gfx_ctx_x_vk_swap_buffers(void *data)
{ {
gfx_ctx_x_vk_data_t *x = (gfx_ctx_x_vk_data_t*)data; gfx_ctx_x_vk_data_t *x = (gfx_ctx_x_vk_data_t*)data;
if (x->vk.context.has_acquired_swapchain) if (x->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{ {
x->vk.context.has_acquired_swapchain = false; x->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (x->vk.swapchain == VK_NULL_HANDLE) if (x->vk.swapchain == VK_NULL_HANDLE)
{ {
retro_sleep(10); retro_sleep(10);
@ -200,8 +200,8 @@ static bool gfx_ctx_x_vk_set_resize(void *data,
if (x->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN) if (x->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&x->vk); vulkan_acquire_next_image(&x->vk);
x->vk.context.invalid_swapchain = true; x->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
x->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN; x->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true; return true;
} }