// Copyright 2018 The clvk authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <cmath>

#include "image_format.hpp"
#include "memory.hpp"
#include "queue.hpp"

bool cvk_mem::map_memory() {
    std::lock_guard<std::mutex> lock(m_map_lock);
    cvk_debug("%p::map", this);

    if (m_map_count == 0) {
        if (m_parent != nullptr) {
            if (!m_parent->map()) {
                return false;
            }
            m_map_ptr = pointer_offset(m_parent->host_va(), m_parent_offset);
            cvk_debug("%p::map, sub-buffer, map_ptr = %p", this, m_map_ptr);
        } else {
            auto res = m_memory->map(&m_map_ptr);
            if (res != VK_SUCCESS) {
                return false;
            }
            cvk_debug("%p::map, map_ptr = %p", this, m_map_ptr);
        }
    }

    m_map_count++;
    retain();
    cvk_debug("%p::map, new map_count = %u", this, m_map_count);

    return true;
}

void cvk_mem::unmap_memory() {
    std::lock_guard<std::mutex> lock(m_map_lock);
    cvk_debug("%p::unmap", this);

    CVK_ASSERT(m_map_count > 0);
    m_map_count--;
    release();
    if (m_map_count == 0) {
        if (m_parent != nullptr) {
            m_parent->unmap();
            cvk_debug("%p::unmap, sub-buffer", this);
        } else {
            m_memory->unmap();
            m_map_ptr = nullptr;
        }
    }
    cvk_debug("%p::unmap, new map_count = %u", this, m_map_count);
}

void cvk_mem::invalidate_memory(VkDeviceSize offset, VkDeviceSize size) {
    if (m_parent != nullptr) {
        m_parent->invalidate_memory(offset + m_parent_offset, size);
    } else {
        m_memory->invalidate(offset, size);
    }
}

void cvk_mem::flush_memory(VkDeviceSize offset, VkDeviceSize size) {
    if (m_parent != nullptr) {
        m_parent->flush_memory(offset + m_parent_offset, size);
    } else {
        m_memory->flush(offset, size);
    }
}

std::unique_ptr<cvk_buffer>
cvk_buffer::create(cvk_context* context, cl_mem_flags flags, size_t size,
                   void* host_ptr, std::vector<cl_mem_properties>&& properties,
                   cl_int* errcode_ret) {
    auto buffer = std::make_unique<cvk_buffer>(
        context, flags, size, host_ptr, nullptr, 0, std::move(properties));

    if (!buffer->init()) {
        *errcode_ret = CL_OUT_OF_RESOURCES;
        return nullptr;
    }

    *errcode_ret = CL_SUCCESS;
    return buffer;
}

bool cvk_buffer::init() {
    auto device = m_context->device();
    auto vkdev = device->vulkan_device();

    // Create the buffer
    const VkBufferCreateInfo createInfo = {
        VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
        nullptr,                              // pNext
        0,                                    // flags
        m_size,
        prepare_usage_flags(), // usage
        VK_SHARING_MODE_EXCLUSIVE,
        0,       // queueFamilyIndexCount
        nullptr, // pQueueFamilyIndices
    };

    VkResult res = vkCreateBuffer(vkdev, &createInfo, nullptr, &m_buffer);

    if (res != VK_SUCCESS) {
        return false;
    }

    // Select memory type
    cvk_device::allocation_parameters params =
        device->select_memory_for(m_buffer, flags());
    if (params.memory_type_index == VK_MAX_MEMORY_TYPES) {
        return false;
    }

    // Allocate memory
    m_memory = std::make_shared<cvk_memory_allocation>(
        vkdev, params.size, params.memory_type_index, params.memory_coherent,
        device->keep_memory_allocations_mapped());
    res = m_memory->allocate(device->uses_physical_addressing());

    if (res != VK_SUCCESS) {
        return false;
    }

    // Bind the buffer to memory
    res = vkBindBufferMemory(vkdev, m_buffer, m_memory->vulkan_memory(), 0);

    if (res != VK_SUCCESS) {
        return false;
    }

    if (has_any_flag(CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) {
        if (!copy_from(m_host_ptr, 0, m_size)) {
            return false;
        }
    }

    return true;
}

cvk_mem* cvk_buffer::create_subbuffer(cl_mem_flags flags, size_t origin,
                                      size_t size) {
    std::vector<cl_mem_properties> properties;
    auto buffer = std::make_unique<cvk_buffer>(
        m_context, flags, size, nullptr, this, origin, std::move(properties));

    return buffer.release();
}

cvk_sampler*
cvk_sampler::create(cvk_context* context, bool normalized_coords,
                    cl_addressing_mode addressing_mode,
                    cl_filter_mode filter_mode,
                    std::vector<cl_sampler_properties>&& properties) {
    auto sampler = std::make_unique<cvk_sampler>(context, normalized_coords,
                                                 addressing_mode, filter_mode,
                                                 std::move(properties));

    if (!sampler->init()) {
        return nullptr;
    }

    return sampler.release();
}

bool cvk_sampler::init(bool force_normalized_coordinates) {
    auto vkdev = context()->device()->vulkan_device();

    // Translate addressing mode
    VkSamplerAddressMode address_mode;
    switch (m_addressing_mode) {
    default:
    case CL_ADDRESS_NONE:
        address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        break;
    case CL_ADDRESS_CLAMP_TO_EDGE:
        address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        break;
    case CL_ADDRESS_CLAMP:
        address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        break;
    case CL_ADDRESS_REPEAT:
        address_mode = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        break;
    case CL_ADDRESS_MIRRORED_REPEAT:
        address_mode = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
        break;
    }

    // Translate filtering
    VkFilter filter;
    VkSamplerMipmapMode mipmap_mode;
    switch (m_filter_mode) {
    case CL_FILTER_LINEAR:
        if (config.supports_filter_linear) {
            filter = VK_FILTER_LINEAR;
            mipmap_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
            break;
        } else {
            cvk_warn_fn(
                "linear filter is not supported, using nearest filter instead");
        }
        [[fallthrough]];
    default:
    case CL_FILTER_NEAREST:
        filter = VK_FILTER_NEAREST;
        mipmap_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
        break;
    }

    // Translate coordinate type
    VkBool32 unnormalized_coordinates;
    if (m_normalized_coords || force_normalized_coordinates) {
        unnormalized_coordinates = VK_FALSE;
    } else {
        unnormalized_coordinates = VK_TRUE;
        // VUID-01073: unnormalized coords must use nearest mipmap filtering.
        mipmap_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
        // VUID-01075: unnormalized coords must use clamp to edge or border
        // addressing
        if ((address_mode != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) &&
            (address_mode != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) {
            address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        }
    }

    // TODO this is a rough first pass, dig into the details
    const VkSamplerCreateInfo create_info = {
        VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        nullptr,                               // pNext
        0,                                     // flags
        filter,                                // magFilter
        filter,                                // minFilter
        mipmap_mode,                           // mipmapMode
        address_mode,                          // addressModeU
        address_mode,                          // addressModeV
        address_mode,                          // addressModeW
        0.0f,                                  // mipLodBias
        VK_FALSE,                              // anisotropyEnable
        0.0f,                                  // maxAnisotropy
        VK_FALSE,                              // compareEnable
        VK_COMPARE_OP_NEVER,                   // compareOp
        0.0f,                                  // minLod
        0.0f,                                  // maxLod
        VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, // borderColor
        unnormalized_coordinates,              // unnormalizedCoordinates
    };

    VkSampler* sampler =
        force_normalized_coordinates ? &m_sampler_norm : &m_sampler;
    auto res = vkCreateSampler(vkdev, &create_info, nullptr, sampler);

    return (res == VK_SUCCESS);
}

VkFormatFeatureFlags
cvk_image::required_format_feature_flags_for(cl_mem_object_type type,
                                             cl_mem_flags flags) {
    // 1Dbuffer requires
    //  RW / RaW: STORAGE_TEXEL_BUFFER
    //  RO: UNIFORM_TEXEL_BUFFER
    // All other images require TRANSFER_SRC, TRANSFER_DST
    //  read-only: SAMPLED_IMAGE, SAMPLED_IMAGE_FILTER_LINEAR
    //  write-only: STORAGE_IMAGE
    //  read-write: STORAGE_IMAGE, SAMPLED_IMAGE, SAMPLED_IMAGE_FILTER_LINEAR
    //  read-and-write: STORAGE_IMAGE
    VkFormatFeatureFlags format_feature_flags = 0;
    if (type != CL_MEM_OBJECT_IMAGE1D_BUFFER) {
        format_feature_flags = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
                               VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
    }
    VkFormatFeatureFlags format_feature_flags_RO;
    if (type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
        format_feature_flags_RO = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
    } else {
        format_feature_flags_RO = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
        if (config.supports_filter_linear()) {
            format_feature_flags_RO |=
                VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
        }
    }
    VkFormatFeatureFlags format_feature_flags_WO;
    if (type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
        format_feature_flags_WO = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
    } else {
        format_feature_flags_WO = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
    }

    if (flags & (CL_MEM_KERNEL_READ_AND_WRITE | CL_MEM_WRITE_ONLY)) {
        format_feature_flags |= format_feature_flags_WO;
    } else if (flags & CL_MEM_READ_ONLY) {
        format_feature_flags |= format_feature_flags_RO;
    } else {
        format_feature_flags |=
            format_feature_flags_RO | format_feature_flags_WO;
    }

    return format_feature_flags;
}

cvk_image* cvk_image::create(cvk_context* ctx, cl_mem_flags flags,
                             const cl_image_desc* desc,
                             const cl_image_format* format, void* host_ptr,
                             std::vector<cl_mem_properties>&& properties) {
    auto image = std::make_unique<cvk_image>(ctx, flags, desc, format, host_ptr,
                                             std::move(properties));

    if (!image->init()) {
        return nullptr;
    }

    return image.release();
}

bool cvk_image::init_vulkan_image() {
    // Translate image type and size
    VkImageType image_type;
    VkImageViewType view_type;
    VkExtent3D extent;

    extent.width = m_desc.image_width;
    extent.height = m_desc.image_height;
    extent.depth = m_desc.image_depth;

    uint32_t array_layers = 1;
    if ((m_desc.image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) ||
        (m_desc.image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY)) {
        array_layers = m_desc.image_array_size;
    }

    uint32_t row_pitch = m_desc.image_row_pitch;
    if (row_pitch == 0) {
        row_pitch = m_desc.image_width * element_size();
    }
    uint32_t slice_pitch = m_desc.image_slice_pitch;
    if (slice_pitch == 0) {
        slice_pitch = row_pitch * m_desc.image_height;
    }

    size_t host_ptr_size = 0;

    switch (m_desc.image_type) {
    case CL_MEM_OBJECT_IMAGE1D:
        image_type = VK_IMAGE_TYPE_1D;
        view_type = VK_IMAGE_VIEW_TYPE_1D;
        extent.height = 1;
        extent.depth = 1;
        host_ptr_size = row_pitch;
        break;
    case CL_MEM_OBJECT_IMAGE1D_ARRAY:
        image_type = VK_IMAGE_TYPE_1D;
        view_type = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
        extent.height = 1;
        extent.depth = 1;
        host_ptr_size = row_pitch * array_layers;
        break;
    case CL_MEM_OBJECT_IMAGE2D:
        image_type = VK_IMAGE_TYPE_2D;
        view_type = VK_IMAGE_VIEW_TYPE_2D;
        extent.depth = 1;
        host_ptr_size = slice_pitch;
        break;
    case CL_MEM_OBJECT_IMAGE2D_ARRAY:
        image_type = VK_IMAGE_TYPE_2D;
        view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
        extent.depth = 1;
        host_ptr_size = slice_pitch * array_layers;
        break;
    case CL_MEM_OBJECT_IMAGE3D:
        image_type = VK_IMAGE_TYPE_3D;
        view_type = VK_IMAGE_VIEW_TYPE_3D;
        host_ptr_size = slice_pitch * m_desc.image_depth;
        break;
    default:
        CVK_ASSERT(false);
        image_type = VK_IMAGE_TYPE_MAX_ENUM;
        view_type = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
        break;
    }

    // Translate format
    image_format_support fmt;
    VkComponentMapping components_sampled, components_storage;

    auto device = m_context->device();

    auto success = cl_image_format_to_vulkan_format(
        m_format, m_desc.image_type, device, &fmt, &components_sampled,
        &components_storage);
    if (!success) {
        return false; // TODO error code
    }

    // Create Image
    VkImageCreateInfo imageCreateInfo = {
        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        nullptr,                   // pNext
        0,                         // flags
        image_type,                // imageType
        fmt.vkfmt,                 // format
        extent,                    // extent
        1,                         // mipLevels
        array_layers,              // arrayLayers
        VK_SAMPLE_COUNT_1_BIT,     // samples
        VK_IMAGE_TILING_OPTIMAL,   // tiling
        prepare_usage_flags(),     // usage
        VK_SHARING_MODE_EXCLUSIVE, // sharingMode
        0,                         // queueFamilyIndexCount
        nullptr,                   // pQueueFamilyIndices
        VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
    };

    auto vkdev = device->vulkan_device();

    auto res = vkCreateImage(vkdev, &imageCreateInfo, nullptr, &m_image);
    if (res != VK_SUCCESS) {
        cvk_error_fn("Could not create image!");
        return false;
    }

    CVK_ASSERT(m_desc.image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER);
    // Select memory type
    cvk_device::allocation_parameters params =
        device->select_memory_for(m_image);
    if (params.memory_type_index == VK_MAX_MEMORY_TYPES) {
        cvk_error_fn("Could not get memory type!");
        return false;
    }

    // Allocate memory
    m_memory = std::make_unique<cvk_memory_allocation>(
        vkdev, params.size, params.memory_type_index, params.memory_coherent,
        device->keep_memory_allocations_mapped());

    res = m_memory->allocate(device->uses_physical_addressing());

    if (res != VK_SUCCESS) {
        cvk_error_fn("Could not allocate memory!");
        return false;
    }

    // Bind the image to memory
    res = vkBindImageMemory(vkdev, m_image, m_memory->vulkan_memory(), 0);

    if (res != VK_SUCCESS) {
        return false;
    }

    // Create image view
    VkImageSubresourceRange subresource = {
        VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
        0,                         // baseMipLevel
        1,                         // levelCount
        0,                         // baseArrayLayer
        array_layers,              // layerCount
    };

    VkImageViewCreateInfo imageViewCreateInfo = {
        VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        nullptr,            // pNext
        0,                  // flags
        m_image,            // image
        view_type,          // viewType;
        fmt.vkfmt,          // format
        components_sampled, // components
        subresource,        // subresourceRange
    };

    res = vkCreateImageView(vkdev, &imageViewCreateInfo, nullptr,
                            &m_sampled_view);

    if (res != VK_SUCCESS) {
        return false;
    }

    imageViewCreateInfo.components = components_storage;

    res = vkCreateImageView(vkdev, &imageViewCreateInfo, nullptr,
                            &m_storage_view);

    if (res != VK_SUCCESS) {
        return false;
    }

    if (has_any_flag(CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) {
        // Create a staging buffer to copy to the device later.
        cl_int ret;
        m_init_data = cvk_buffer::create(m_context, CL_MEM_READ_ONLY,
                                         host_ptr_size, nullptr, &ret);
        if (ret != CL_SUCCESS) {
            cvk_error("Could not create staging buffer for image host_ptr");
            return false;
        }

        if (!m_init_data->copy_from(m_host_ptr, 0, host_ptr_size)) {
            cvk_error(
                "Could not copy image host_ptr data to the staging buffer");
            return false;
        }

        if (config.init_image_at_creation()) {
            auto queue = m_context->get_or_create_image_init_command_queue();
            if (queue == nullptr) {
                return false;
            }

            auto initimage = new cvk_command_image_init(queue, this);
            ret = queue->enqueue_command_with_deps(initimage, 0, nullptr,
                                                   nullptr);
            if (ret != CL_SUCCESS) {
                return false;
            }
            ret = queue->finish();
            if (ret != CL_SUCCESS) {
                return false;
            }
            std::lock_guard<std::mutex> lock(m_init_tracker.mutex());
            m_init_tracker.set_state(cvk_mem_init_state::completed);
        }
    }

    return true;
}

bool cvk_image::init_vulkan_texel_buffer() {
    VkResult res;

    auto device = m_context->device();
    auto vkdev = device->vulkan_device();

    image_format_support fmt;
    VkComponentMapping components_sampled, components_storage;

    auto success = cl_image_format_to_vulkan_format(
        m_format, m_desc.image_type, device, &fmt, &components_sampled,
        &components_storage);
    if (!success) {
        return false;
    }

    CVK_ASSERT(buffer());
    CVK_ASSERT(buffer()->is_buffer_type());

    auto vkbuf = static_cast<cvk_buffer*>(buffer())->vulkan_buffer();
    auto offset = static_cast<cvk_buffer*>(buffer())->vulkan_buffer_offset();
    // The range should cover exactly the number of texels specified at
    // image creation time.  Don't use WHOLE_SIZE because the row pitch
    // might include additional padding large enough for one or more texels.
    auto range = element_size() * width();

    VkBufferViewCreateInfo createInfo = {
        VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
        nullptr,
        0,         // flags
        vkbuf,     // buffer
        fmt.vkfmt, // format
        offset,    // offset
        range      // range
    };

    res = vkCreateBufferView(vkdev, &createInfo, nullptr, &m_buffer_view);
    if (res != VK_SUCCESS) {
        cvk_error_fn("Could not create buffer view");
        return false;
    }

    buffer()->retain();

    return true;
}

bool cvk_image::init() {
    if (is_backed_by_buffer_view()) {
        return init_vulkan_texel_buffer();
    } else {
        return init_vulkan_image();
    }
}

void cvk_image::prepare_fill_pattern(const void* input_pattern,
                                     fill_pattern_array& pattern,
                                     size_t* size_ret) const {

    auto pat_float = static_cast<const cl_float*>(input_pattern);
    auto pat_int = static_cast<const cl_int*>(input_pattern);
    auto pat_uint = static_cast<const cl_uint*>(input_pattern);

    cl_uchar pat_uchar[4] = {
        static_cast<cl_uchar>(pat_uint[0]),
        static_cast<cl_uchar>(pat_uint[1]),
        static_cast<cl_uchar>(pat_uint[2]),
        static_cast<cl_uchar>(pat_uint[3]),
    };
    cl_ushort pat_ushort[4] = {
        static_cast<cl_ushort>(pat_uint[0]),
        static_cast<cl_ushort>(pat_uint[1]),
        static_cast<cl_ushort>(pat_uint[2]),
        static_cast<cl_ushort>(pat_uint[3]),
    };
    cl_char pat_char[4] = {
        static_cast<cl_char>(pat_int[0]),
        static_cast<cl_char>(pat_int[1]),
        static_cast<cl_char>(pat_int[2]),
        static_cast<cl_char>(pat_int[3]),
    };
    cl_short pat_short[4] = {
        static_cast<cl_short>(pat_int[0]),
        static_cast<cl_short>(pat_int[1]),
        static_cast<cl_short>(pat_int[2]),
        static_cast<cl_short>(pat_int[3]),
    };
    cl_half pat_half[4] = {
        cl_half_from_float(pat_float[0], CL_HALF_RTE),
        cl_half_from_float(pat_float[1], CL_HALF_RTE),
        cl_half_from_float(pat_float[2], CL_HALF_RTE),
        cl_half_from_float(pat_float[3], CL_HALF_RTE),
    };

    size_t size = element_size();
    *size_ret = size;

    auto saturate = [](float x, float min, float max) {
        if (std::isnan(x)) {
            return 0.f;
        } else if (x < min) {
            return min;
        } else if (x > max) {
            return max;
        }
        return x;
    };
    cl_uchar pat_unorm_int8[4] = {
        static_cast<cl_uchar>(saturate(pat_float[0], 0.f, 1.f) * 255.0f),
        static_cast<cl_uchar>(saturate(pat_float[1], 0.f, 1.f) * 255.0f),
        static_cast<cl_uchar>(saturate(pat_float[2], 0.f, 1.f) * 255.0f),
        static_cast<cl_uchar>(saturate(pat_float[3], 0.f, 1.f) * 255.0f)};
    cl_char pat_snorm_int8[4] = {
        static_cast<cl_char>(saturate(pat_float[0], -1.f, 1.f) * 127.0f),
        static_cast<cl_char>(saturate(pat_float[1], -1.f, 1.f) * 127.0f),
        static_cast<cl_char>(saturate(pat_float[2], -1.f, 1.f) * 127.0f),
        static_cast<cl_char>(saturate(pat_float[3], -1.f, 1.f) * 127.0f)};
    cl_ushort pat_unorm_int16[4] = {
        static_cast<cl_ushort>(saturate(pat_float[0], 0.f, 1.f) * 65535.0f),
        static_cast<cl_ushort>(saturate(pat_float[1], 0.f, 1.f) * 65535.0f),
        static_cast<cl_ushort>(saturate(pat_float[2], 0.f, 1.f) * 65535.0f),
        static_cast<cl_ushort>(saturate(pat_float[3], 0.f, 1.f) * 65535.0f)};
    cl_short pat_snorm_int16[4] = {
        static_cast<cl_short>(saturate(pat_float[0], -1.f, 1.f) * 32767.0f),
        static_cast<cl_short>(saturate(pat_float[1], -1.f, 1.f) * 32767.0f),
        static_cast<cl_short>(saturate(pat_float[2], -1.f, 1.f) * 32767.0f),
        static_cast<cl_short>(saturate(pat_float[3], -1.f, 1.f) * 32767.0f)};
    cl_short pat_unorm_short_565 =
        (static_cast<cl_ushort>(saturate(pat_float[0], 0.f, 1.f) * 31.0f)
         << 11) |
        (static_cast<cl_ushort>(saturate(pat_float[1], 0.f, 1.f) * 63.0f)
         << 5) |
        (static_cast<cl_ushort>(saturate(pat_float[2], 0.f, 1.f) * 31.0f));
    cl_short pat_unorm_short_555 =
        (static_cast<cl_ushort>(saturate(pat_float[0], 0.f, 1.f) * 31.0f)
         << 10) |
        (static_cast<cl_ushort>(saturate(pat_float[1], 0.f, 1.f) * 31.0f)
         << 5) |
        (static_cast<cl_ushort>(saturate(pat_float[2], 0.f, 1.f) * 31.0f));
    cl_short pat_unorm_int_101010 =
        (static_cast<cl_uint>(saturate(pat_float[0], 0.f, 1.f) * 1023.0f)
         << 20) |
        (static_cast<cl_uint>(saturate(pat_float[1], 0.f, 1.f) * 1023.0f)
         << 10) |
        (static_cast<cl_uint>(saturate(pat_float[2], 0.f, 1.f) * 1023.0f));
    cl_short pat_unorm_int_101010_2 =
        (static_cast<cl_uint>(saturate(pat_float[0], 0.f, 1.f) * 1023.0f)
         << 22) |
        (static_cast<cl_uint>(saturate(pat_float[1], 0.f, 1.f) * 1023.0f)
         << 12) |
        (static_cast<cl_uint>(saturate(pat_float[1], 0.f, 1.f) * 1023.0f)
         << 2) |
        (static_cast<cl_uint>(saturate(pat_float[3], 0.f, 1.f) * 3.0f));

    const void* cast_pattern = nullptr;
    switch (format().image_channel_data_type) {
    case CL_UNSIGNED_INT8:
        cast_pattern = &pat_uchar;
        break;
    case CL_UNSIGNED_INT16:
        cast_pattern = &pat_ushort;
        break;
    case CL_SIGNED_INT8:
        cast_pattern = &pat_char;
        break;
    case CL_SIGNED_INT16:
        cast_pattern = &pat_short;
        break;
    case CL_FLOAT:
    case CL_UNSIGNED_INT32:
    case CL_SIGNED_INT32:
        cast_pattern = input_pattern;
        break;
    case CL_UNORM_INT8:
        cast_pattern = pat_unorm_int8;
        break;
    case CL_UNORM_INT16:
        cast_pattern = pat_unorm_int16;
        break;
    case CL_SNORM_INT8:
        cast_pattern = pat_snorm_int8;
        break;
    case CL_SNORM_INT16:
        cast_pattern = pat_snorm_int16;
        break;
    case CL_HALF_FLOAT:
        cast_pattern = pat_half;
        break;
    case CL_UNORM_SHORT_565:
        cast_pattern = &pat_unorm_short_565;
        break;
    case CL_UNORM_SHORT_555:
        cast_pattern = &pat_unorm_short_555;
        break;
    case CL_UNORM_INT_101010:
        cast_pattern = &pat_unorm_int_101010;
        break;
    case CL_UNORM_INT_101010_2:
        cast_pattern = &pat_unorm_int_101010_2;
        break;
    default:
        CVK_ASSERT(false);
        return;
    }

    size_t csize = element_size_per_channel();

    switch (format().image_channel_order) {
    case CL_R:
    case CL_RG:
    case CL_RGB:
    case CL_RGBA:
    case CL_LUMINANCE:
    case CL_INTENSITY:
        memcpy(pattern.data(), cast_pattern, size);
        break;
    case CL_BGRA:
        memcpy(pattern.data() + 0 * csize,
               pointer_offset(cast_pattern, 2 * csize), csize);
        memcpy(pattern.data() + 1 * csize,
               pointer_offset(cast_pattern, 1 * csize), csize);
        memcpy(pattern.data() + 2 * csize,
               pointer_offset(cast_pattern, 0 * csize), csize);
        memcpy(pattern.data() + 3 * csize,
               pointer_offset(cast_pattern, 3 * csize), csize);
        break;
    default:
        CVK_ASSERT(false);
    }
}