// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    carnelian::Point,
    euclid::Transform2D,
    fidl::endpoints::{ClientEnd, ServerEnd},
    fidl_fuchsia_sysmem::{
        AllocatorMarker, BufferCollectionConstraints, BufferCollectionSynchronousProxy,
        BufferCollectionTokenMarker, BufferMemoryConstraints, BufferUsage, ColorSpace,
        ColorSpaceType, FormatModifier, HeapType, ImageFormatConstraints,
        PixelFormat as SysmemPixelFormat, PixelFormatType, CPU_USAGE_WRITE_OFTEN,
        FORMAT_MODIFIER_LINEAR,
    },
    fuchsia_component::client::connect_to_service,
    fuchsia_zircon::{self as zx, prelude::*},
    spinel_rs_sys::{SpnCommand, SpnResult::*, *},
    std::{
        cell::RefCell,
        collections::{BTreeMap, HashSet},
        convert::TryFrom,
        f32,
        ffi::CStr,
        fs::File,
        io::Read,
        mem,
        os::raw::{c_char, c_void},
        ptr,
        rc::Rc,
        sync::Arc,
    },
    vk_sys as vk,
};

// Required spinel libraries.
#[link(name = "spinel", kind = "static")]
#[link(name = "compute_common", kind = "static")]
#[link(name = "compute_common_vk", kind = "static")]
#[link(name = "hotsort_vk", kind = "static")]
#[link(name = "hotsort_vk_hs_nvidia_sm35_u64", kind = "static")]
#[link(name = "hotsort_vk_hs_intel_gen8_u64", kind = "static")]
#[link(name = "hotsort_vk_hs_amd_gcn3_u64", kind = "static")]
#[link(name = "spinel_vk", kind = "static")]
#[link(name = "spinel_vk_find_target", kind = "static")]
#[link(name = "spinel_vk_spn_nvidia_sm50", kind = "static")]
#[link(name = "spinel_vk_spn_intel_gen8", kind = "static")]
#[link(name = "spinel_vk_spn_amd_gcn3", kind = "static")]
extern "C" {}

pub enum Path {
    Spinel(SpinelPath),
    Mold(mold::Path),
}

pub trait PathBuilder {
    fn begin(&mut self);
    fn end(&mut self) -> Path;
    fn move_to(&mut self, p: &Point);
    fn line_to(&mut self, p: &Point);
}

pub enum Raster {
    Spinel(SpinelRaster),
    Mold(mold::Raster),
}

pub enum GroupId {
    Spinel(SpnGroupId),
    Mold(u32),
}

pub trait RasterBuilder {
    fn begin(&mut self);
    fn end(&mut self) -> Raster;
    fn add(&mut self, path: &Path, transform: &Transform2D<f32>, clip: &[f32; 4]);
}

pub trait Styling {
    fn seal(&mut self);
    fn unseal(&mut self);
    fn reset(&mut self);
    fn alloc_group(&mut self, range_lo: u32, range_hi: u32, background_color: &[f32; 4])
        -> GroupId;
    fn group_layer(&mut self, group_id: &GroupId, layer_id: u32, color: &[f32; 4]);
}

pub trait Composition {
    fn seal(&mut self);
    fn unseal(&mut self);
    fn reset(&mut self);
    fn set_clip(&mut self, clip: &[u32; 4]);
    fn place(&mut self, raster: &Raster, layer_id: u32);
}

pub trait Image {
    fn flush(&mut self);
}

pub struct CopyRegion {
    pub src_offset: [u32; 2],
    pub dst_offset: [u32; 2],
    pub extent: [u32; 2],
}

#[allow(dead_code)]
pub enum RenderExt {
    // Clear color.
    PreClear([f32; 4]),
    // Source image followed by region to copy. Source can be the same as
    // render image.
    PreCopy((u32, CopyRegion)),
    // Destination image followed by border color, exposure distance and
    // region to copy. Destination image must be different from render image.
    PostCopy((u32, [f32; 4], [i32; 2], CopyRegion)),
}

pub trait Context {
    fn get_pixel_format(&self) -> fuchsia_framebuffer::PixelFormat;
    fn styling(&mut self) -> &mut dyn Styling;
    fn path_builder(&mut self) -> &mut dyn PathBuilder;
    fn raster_builder(&mut self) -> &mut dyn RasterBuilder;
    fn composition(&mut self, id: u32) -> &mut dyn Composition;
    fn image(&mut self, id: u32, size: &[u32; 2]) -> &mut dyn Image;
    fn image_from_index(&mut self, id: u32, index: u32) -> &mut dyn Image;
    fn render(&mut self, image_id: u32, composition_id: u32, clip: &[u32; 4], exts: &[RenderExt]);
}

//
// Spinel Implementation
//

pub struct SpinelPath {
    context: Rc<RefCell<SpnContext>>,
    path: SpnPath,
}

impl SpinelPath {
    fn new(context: Rc<RefCell<SpnContext>>, path: SpnPath) -> Self {
        Self { context, path }
    }
}

impl Drop for SpinelPath {
    fn drop(&mut self) {
        unsafe {
            spn_path_release(*self.context.borrow(), &self.path as *const _, 1);
        }
    }
}

pub struct SpinelRaster {
    context: Rc<RefCell<SpnContext>>,
    raster: SpnRaster,
}

impl SpinelRaster {
    fn new(context: Rc<RefCell<SpnContext>>, raster: SpnRaster) -> Self {
        Self { context, raster }
    }
}

impl Drop for SpinelRaster {
    fn drop(&mut self) {
        unsafe {
            spn_raster_release(*self.context.borrow(), &self.raster as *const _, 1);
        }
    }
}

struct SpinelPathBuilder {
    context: Rc<RefCell<SpnContext>>,
    path_builder: SpnPathBuilder,
}

impl SpinelPathBuilder {
    fn new(context: Rc<RefCell<SpnContext>>) -> Self {
        let path_builder = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_path_builder_create(*context.borrow(), output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        Self { context, path_builder }
    }
}

impl PathBuilder for SpinelPathBuilder {
    fn begin(&mut self) {
        unsafe {
            let status = spn_path_builder_begin(self.path_builder);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn end(&mut self) -> Path {
        let path = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_path_builder_end(self.path_builder, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };
        Path::Spinel(SpinelPath::new(Rc::clone(&self.context), path))
    }

    fn move_to(&mut self, p: &Point) {
        unsafe {
            let status = spn_path_builder_move_to(self.path_builder, p.x, p.y);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn line_to(&mut self, p: &Point) {
        unsafe {
            let status = spn_path_builder_line_to(self.path_builder, p.x, p.y);
            assert_eq!(status, SpnSuccess);
        }
    }
}

impl Drop for SpinelPathBuilder {
    fn drop(&mut self) {
        unsafe {
            spn_path_builder_release(self.path_builder);
        }
    }
}

struct SpinelRasterBuilder {
    context: Rc<RefCell<SpnContext>>,
    raster_builder: SpnRasterBuilder,
}

impl SpinelRasterBuilder {
    fn new(context: Rc<RefCell<SpnContext>>) -> Self {
        let raster_builder = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_raster_builder_create(*context.borrow(), output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        Self { context, raster_builder }
    }
}

impl RasterBuilder for SpinelRasterBuilder {
    fn begin(&mut self) {
        unsafe {
            let status = spn_raster_builder_begin(self.raster_builder);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn end(&mut self) -> Raster {
        let raster = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_raster_builder_end(self.raster_builder, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };
        Raster::Spinel(SpinelRaster::new(Rc::clone(&self.context), raster))
    }

    fn add(&mut self, path: &Path, transform: &Transform2D<f32>, clip: &[f32; 4]) {
        let transform = SpnTransform {
            sx: transform.m11 * 32.0,
            shx: transform.m21 * 32.0,
            tx: transform.m31 * 32.0,
            shy: transform.m12 * 32.0,
            sy: transform.m22 * 32.0,
            ty: transform.m32 * 32.0,
            w0: 0.0,
            w1: 0.0,
        };
        let clip = SpnClip { x0: clip[0], y0: clip[1], x1: clip[2], y1: clip[3] };
        match path {
            Path::Spinel(path) => unsafe {
                let status = spn_raster_builder_add(
                    self.raster_builder,
                    &path.path,
                    ptr::null_mut(),
                    &transform,
                    ptr::null_mut(),
                    &clip,
                    1,
                );
                assert_eq!(status, SpnSuccess);
            },
            _ => {
                panic!("bad path");
            }
        }
    }
}

impl Drop for SpinelRasterBuilder {
    fn drop(&mut self) {
        unsafe {
            spn_raster_builder_release(self.raster_builder);
        }
    }
}

struct SpinelStyling {
    styling: SpnStyling,
}

impl SpinelStyling {
    fn new(context: Rc<RefCell<SpnContext>>, layers_count: u32, cmds_count: u32) -> Self {
        let styling = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_styling_create(
                *context.borrow(),
                output.as_mut_ptr(),
                layers_count,
                cmds_count,
            );
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        Self { styling }
    }
}

impl Styling for SpinelStyling {
    fn seal(&mut self) {
        unsafe {
            let status = spn_styling_seal(self.styling);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn unseal(&mut self) {
        unsafe {
            let status = spn_styling_unseal(self.styling);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn reset(&mut self) {
        unsafe {
            let status = spn_styling_reset(self.styling);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn alloc_group(
        &mut self,
        range_lo: u32,
        range_hi: u32,
        background_color: &[f32; 4],
    ) -> GroupId {
        let group_id = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_styling_group_alloc(self.styling, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        unsafe {
            let status = spn_styling_group_parents(self.styling, group_id, 0, ptr::null_mut());
            assert_eq!(status, SpnSuccess);
            spn_styling_group_range_lo(self.styling, group_id, range_lo);
            spn_styling_group_range_hi(self.styling, group_id, range_hi);
        }

        let cmds_enter = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_styling_group_enter(self.styling, group_id, 1, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            std::slice::from_raw_parts_mut(output.assume_init(), 1)
        };
        cmds_enter[0] = SpnCommand::SpnStylingOpcodeColorAccZero;

        let cmds_leave = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_styling_group_leave(self.styling, group_id, 4, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            std::slice::from_raw_parts_mut(output.assume_init(), 4)
        };

        unsafe {
            spn_styling_background_over_encoder(&mut cmds_leave[0], background_color.as_ptr());
        }
        cmds_leave[3] = SpnCommand::SpnStylingOpcodeColorAccStoreToSurface;

        GroupId::Spinel(group_id)
    }

    fn group_layer(&mut self, group_id: &GroupId, layer_id: u32, color: &[f32; 4]) {
        let group_id = match group_id {
            GroupId::Spinel(id) => *id,
            _ => panic!("invalid group id"),
        };
        let cmds = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status =
                spn_styling_group_layer(self.styling, group_id, layer_id, 6, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            std::slice::from_raw_parts_mut(output.assume_init(), 6)
        };
        cmds[0] = SpnCommand::SpnStylingOpcodeCoverWipZero;
        cmds[1] = SpnCommand::SpnStylingOpcodeCoverNonzero;
        unsafe {
            spn_styling_layer_fill_rgba_encoder(&mut cmds[2], color.as_ptr());
        }
        cmds[5] = SpnCommand::SpnStylingOpcodeBlendOver;
    }
}

impl Drop for SpinelStyling {
    fn drop(&mut self) {
        unsafe {
            spn_styling_release(self.styling);
        }
    }
}

struct SpinelComposition {
    composition: SpnComposition,
}

impl SpinelComposition {
    fn new(context: Rc<RefCell<SpnContext>>) -> Self {
        let composition = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status = spn_composition_create(*context.borrow(), output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        Self { composition }
    }
}

impl Composition for SpinelComposition {
    fn seal(&mut self) {
        unsafe {
            let status = spn_composition_seal(self.composition);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn unseal(&mut self) {
        unsafe {
            let status = spn_composition_unseal(self.composition);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn reset(&mut self) {
        unsafe {
            let status = spn_composition_reset(self.composition);
            assert_eq!(status, SpnSuccess);
        }
    }

    fn set_clip(&mut self, clip: &[u32; 4]) {
        unsafe {
            let status = spn_composition_set_clip(self.composition, clip.as_ptr());
            assert_eq!(status, SpnSuccess);
        }
    }
    fn place(&mut self, raster: &Raster, layer_id: u32) {
        match raster {
            Raster::Spinel(raster) => unsafe {
                let status = spn_composition_place(
                    self.composition,
                    &raster.raster,
                    &layer_id,
                    ptr::null(),
                    1,
                );
                assert_eq!(status, SpnSuccess);
            },
            _ => {
                panic!("bad raster");
            }
        }
    }
}

impl Drop for SpinelComposition {
    fn drop(&mut self) {
        unsafe {
            spn_composition_release(self.composition);
        }
    }
}

// TODO: Remove buffer collection bindings when they are upstream.

type BufferCollectionFUCHSIA = u64;

const STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: u32 = 1001004000;
const STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: u32 = 1001004004;
const STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: u32 = 1001004005;
const STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: u32 = 1001004006;

#[repr(C)]
#[allow(non_snake_case)]
struct BufferCollectionCreateInfoFUCHSIA {
    sType: vk::StructureType,
    pNext: *const ::std::os::raw::c_void,
    collectionToken: u32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct ImportMemoryBufferCollectionFUCHSIA {
    sType: vk::StructureType,
    pNext: *const ::std::os::raw::c_void,
    collection: BufferCollectionFUCHSIA,
    index: u32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct BufferCollectionImageCreateInfoFUCHSIA {
    sType: vk::StructureType,
    pNext: *const ::std::os::raw::c_void,
    collection: BufferCollectionFUCHSIA,
    index: u32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct BufferCollectionPropertiesFUCHSIA {
    sType: vk::StructureType,
    pNext: *const ::std::os::raw::c_void,
    memoryTypeBits: u32,
    count: u32,
}

macro_rules! ptrs {(
    $struct_name:ident,
    { $($name:ident => ($($param_n:ident: $param_ty:ty),*) -> $ret:ty,)+ }) => (
        #[allow(non_snake_case)]
        struct $struct_name {
            $(
                pub $name: extern "system" fn($($param_ty),*) -> $ret,
            )+
        }

        impl $struct_name {
            fn load<F>(mut f: F) -> $struct_name
                where F: FnMut(&CStr) -> *const ::std::os::raw::c_void
            {
                #[allow(non_snake_case)]
                $struct_name {
                    $(
                        $name: unsafe {
                            extern "system" fn $name($(_: $param_ty),*) {
                                panic!("function pointer `{}` not loaded", stringify!($name))
                            }
                            let name = CStr::from_bytes_with_nul_unchecked(
                                concat!("vk", stringify!($name), "\0").as_bytes());
                            let val = f(name);
                            if val.is_null() {
                                mem::transmute($name as *const ())
                            } else {
                                mem::transmute(val)
                            }
                        },
                    )+
                }
            }

            $(
                #[inline]
                #[allow(non_snake_case)]
                unsafe fn $name(&self $(, $param_n: $param_ty)*) -> $ret {
                    let ptr = self.$name;
                    ptr($($param_n),*)
                }
            )+
        }
    )
}

ptrs!(FuchsiaExtensionPointers, {
    CreateBufferCollectionFUCHSIA => (
        device: vk::Device,
        pImportInfo: *const BufferCollectionCreateInfoFUCHSIA,
        pAllocator: *const vk::AllocationCallbacks,
        pCollection: *mut BufferCollectionFUCHSIA) -> vk::Result,
    SetBufferCollectionConstraintsFUCHSIA => (
        device: vk::Device,
        collection: BufferCollectionFUCHSIA,
        pImageInfo: *const vk::ImageCreateInfo) -> vk::Result,
    DestroyBufferCollectionFUCHSIA => (
        device: vk::Device,
        collection: BufferCollectionFUCHSIA,
        pAllocator: *const vk::AllocationCallbacks) -> (),
    GetBufferCollectionPropertiesFUCHSIA => (
        device: vk::Device,
        collection: BufferCollectionFUCHSIA,
        pProperties: *mut BufferCollectionPropertiesFUCHSIA) -> vk::Result,
});

#[link(name = "vulkan")]
extern "C" {
    fn vkGetInstanceProcAddr(
        instance: vk::Instance,
        pName: *const ::std::os::raw::c_char,
    ) -> vk::PFN_vkVoidFunction;
}

const STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: u32 = 1000059000;
const STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: u32 = 1000261000;
const STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: u32 = 1000269000;
const STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: u32 = 1000221000;
const STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: u32 = 1000082000;
const STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: u32 = 1000225002;

#[repr(C)]
#[allow(non_snake_case)]
struct PhysicalDeviceHostQueryResetFeaturesEXT {
    sType: vk::StructureType,
    pNext: *const c_void,
    hostQueryReset: vk::Bool32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    sType: vk::StructureType,
    pNext: *const c_void,
    pipelineExecutableInfo: vk::Bool32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct PhysicalDeviceScalarBlockLayoutFeaturesEXT {
    sType: vk::StructureType,
    pNext: *const c_void,
    scalarBlockLayout: vk::Bool32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
    sType: vk::StructureType,
    pNext: *const c_void,
    shaderFloat16: vk::Bool32,
    shaderInt8: vk::Bool32,
}

#[repr(C)]
#[allow(non_snake_case)]
struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
    sType: vk::StructureType,
    pNext: *const c_void,
    subgroupSizeControl: vk::Bool32,
    computeFullSubgroups: vk::Bool32,
}

struct VulkanImage {
    device: vk::Device,
    image: vk::Image,
    sampler: vk::Sampler,
    view: vk::ImageView,
    memory: vk::DeviceMemory,
    vk: vk::DevicePointers,
    width: u32,
    height: u32,
    layout: vk::ImageLayout,
    stage: vk::PipelineStageFlagBits,
    access_mask: vk::AccessFlags,
    pool: Option<vk::CommandPool>,
    cb: Option<vk::CommandBuffer>,
    queue: Option<vk::Queue>,
    fence: Option<vk::Fence>,
}

impl VulkanImage {
    fn get_image_create_info(
        width: u32,
        height: u32,
        format: vk::Format,
        p_next: *const c_void,
    ) -> vk::ImageCreateInfo {
        vk::ImageCreateInfo {
            sType: vk::STRUCTURE_TYPE_IMAGE_CREATE_INFO,
            pNext: p_next,
            flags: 0,
            imageType: vk::IMAGE_TYPE_2D,
            format,
            extent: vk::Extent3D { width, height, depth: 1 },
            mipLevels: 1,
            arrayLayers: 1,
            samples: vk::SAMPLE_COUNT_1_BIT,
            tiling: vk::IMAGE_TILING_OPTIMAL,
            usage: vk::IMAGE_USAGE_COLOR_ATTACHMENT_BIT
                | vk::IMAGE_USAGE_STORAGE_BIT
                | vk::IMAGE_USAGE_TRANSFER_SRC_BIT
                | vk::IMAGE_USAGE_TRANSFER_DST_BIT,
            sharingMode: vk::SHARING_MODE_EXCLUSIVE,
            queueFamilyIndexCount: 0,
            pQueueFamilyIndices: ptr::null(),
            initialLayout: vk::IMAGE_LAYOUT_UNDEFINED,
        }
    }

    fn new(
        device: vk::Device,
        vk_i: &vk::InstancePointers,
        width: u32,
        height: u32,
        format: vk::Format,
    ) -> Self {
        let vk = vk::DevicePointers::load(|name| unsafe {
            vk_i.GetDeviceProcAddr(device, name.as_ptr()) as *const _
        });
        let image = unsafe {
            let info = Self::get_image_create_info(width, height, format, ptr::null());
            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateImage(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let mem_reqs = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            vk.GetImageMemoryRequirements(device, image, output.as_mut_ptr());
            output.assume_init()
        };

        let mem_type_bits = mem_reqs.memoryTypeBits;
        assert_ne!(mem_type_bits, 0);
        let mem_type_index = {
            let mut bits = mem_type_bits;
            let mut index = 0;
            while (bits & 1) == 0 {
                index += 1;
                bits >>= 1;
            }
            index
        };

        let memory = unsafe {
            let alloc_info = vk::MemoryAllocateInfo {
                sType: vk::STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                pNext: ptr::null(),
                allocationSize: mem_reqs.size as u64,
                memoryTypeIndex: mem_type_index,
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.AllocateMemory(device, &alloc_info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        unsafe {
            let result = vk.BindImageMemory(device, image, memory, 0);
            assert_eq!(result, vk::SUCCESS);
        }

        let sampler = unsafe {
            let info = vk::SamplerCreateInfo {
                sType: vk::STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                magFilter: vk::FILTER_NEAREST,
                minFilter: vk::FILTER_NEAREST,
                mipmapMode: vk::SAMPLER_MIPMAP_MODE_NEAREST,
                addressModeU: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                addressModeV: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                addressModeW: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                mipLodBias: 0.0,
                anisotropyEnable: vk::FALSE,
                maxAnisotropy: 1.0,
                compareEnable: vk::FALSE,
                compareOp: vk::COMPARE_OP_NEVER,
                minLod: 0.0,
                maxLod: 0.0,
                borderColor: vk::BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
                unnormalizedCoordinates: vk::TRUE,
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateSampler(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let view = unsafe {
            let info = vk::ImageViewCreateInfo {
                sType: vk::STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                image: image,
                viewType: vk::IMAGE_VIEW_TYPE_2D,
                format,
                components: vk::ComponentMapping {
                    r: vk::COMPONENT_SWIZZLE_R,
                    g: vk::COMPONENT_SWIZZLE_G,
                    b: vk::COMPONENT_SWIZZLE_B,
                    a: vk::COMPONENT_SWIZZLE_A,
                },
                subresourceRange: vk::ImageSubresourceRange {
                    aspectMask: vk::IMAGE_ASPECT_COLOR_BIT,
                    baseMipLevel: 0,
                    levelCount: 1,
                    baseArrayLayer: 0,
                    layerCount: 1,
                },
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateImageView(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        VulkanImage {
            device,
            image,
            sampler,
            view,
            memory,
            vk,
            width,
            height,
            layout: vk::IMAGE_LAYOUT_UNDEFINED,
            stage: vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
            access_mask: 0,
            pool: None,
            cb: None,
            queue: None,
            fence: None,
        }
    }

    fn from_buffer_collection(
        device: vk::Device,
        vk_i: &vk::InstancePointers,
        vk_ext: &FuchsiaExtensionPointers,
        width: u32,
        height: u32,
        format: vk::Format,
        buffer_collection: BufferCollectionFUCHSIA,
        index: u32,
    ) -> Self {
        let vk = vk::DevicePointers::load(|name| unsafe {
            vk_i.GetDeviceProcAddr(device, name.as_ptr()) as *const _
        });
        let image = unsafe {
            let buffer_collection_info = BufferCollectionImageCreateInfoFUCHSIA {
                sType: STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
                pNext: ptr::null(),
                collection: buffer_collection,
                index: index,
            };
            let info = Self::get_image_create_info(
                width,
                height,
                format,
                &buffer_collection_info as *const _ as *const c_void,
            );

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateImage(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let mem_reqs = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            vk.GetImageMemoryRequirements(device, image, output.as_mut_ptr());
            output.assume_init()
        };

        let mut mem_props = unsafe {
            let output = mem::MaybeUninit::<BufferCollectionPropertiesFUCHSIA>::zeroed();
            output.assume_init()
        };
        mem_props.sType = STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA;
        unsafe {
            let result = vk_ext.GetBufferCollectionPropertiesFUCHSIA(
                device,
                buffer_collection,
                &mut mem_props,
            );
            assert_eq!(result, vk::SUCCESS);
        }
        let mem_type_bits = mem_reqs.memoryTypeBits & mem_props.memoryTypeBits;
        assert_ne!(mem_type_bits, 0);
        let mem_type_index = {
            let mut bits = mem_type_bits;
            let mut index = 0;
            while (bits & 1) == 0 {
                index += 1;
                bits >>= 1;
            }
            index
        };

        let memory = unsafe {
            let import_info = ImportMemoryBufferCollectionFUCHSIA {
                sType: STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
                pNext: ptr::null(),
                collection: buffer_collection,
                index: index,
            };
            let alloc_info = vk::MemoryAllocateInfo {
                sType: vk::STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                pNext: &import_info as *const _ as *const c_void,
                allocationSize: mem_reqs.size as u64,
                memoryTypeIndex: mem_type_index,
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.AllocateMemory(device, &alloc_info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        unsafe {
            let result = vk.BindImageMemory(device, image, memory, 0);
            assert_eq!(result, vk::SUCCESS);
        }

        let sampler = unsafe {
            let info = vk::SamplerCreateInfo {
                sType: vk::STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                magFilter: vk::FILTER_NEAREST,
                minFilter: vk::FILTER_NEAREST,
                mipmapMode: vk::SAMPLER_MIPMAP_MODE_NEAREST,
                addressModeU: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                addressModeV: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                addressModeW: vk::SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                mipLodBias: 0.0,
                anisotropyEnable: vk::FALSE,
                maxAnisotropy: 1.0,
                compareEnable: vk::FALSE,
                compareOp: vk::COMPARE_OP_NEVER,
                minLod: 0.0,
                maxLod: 0.0,
                borderColor: vk::BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
                unnormalizedCoordinates: vk::TRUE,
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateSampler(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let view = unsafe {
            let info = vk::ImageViewCreateInfo {
                sType: vk::STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                image: image,
                viewType: vk::IMAGE_VIEW_TYPE_2D,
                format,
                components: vk::ComponentMapping {
                    r: vk::COMPONENT_SWIZZLE_R,
                    g: vk::COMPONENT_SWIZZLE_G,
                    b: vk::COMPONENT_SWIZZLE_B,
                    a: vk::COMPONENT_SWIZZLE_A,
                },
                subresourceRange: vk::ImageSubresourceRange {
                    aspectMask: vk::IMAGE_ASPECT_COLOR_BIT,
                    baseMipLevel: 0,
                    levelCount: 1,
                    baseArrayLayer: 0,
                    layerCount: 1,
                },
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateImageView(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        VulkanImage {
            device,
            image,
            sampler,
            view,
            memory,
            vk,
            width,
            height,
            layout: vk::IMAGE_LAYOUT_UNDEFINED,
            stage: vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
            access_mask: 0,
            pool: None,
            cb: None,
            queue: None,
            fence: None,
        }
    }

    fn layout_transition(
        &mut self,
        new_layout: vk::ImageLayout,
        stage: vk::PipelineStageFlagBits,
        access_mask: vk::AccessFlagBits,
    ) {
        let pool = self.pool.take().unwrap_or_else(|| unsafe {
            let info = vk::CommandPoolCreateInfo {
                sType: vk::STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
                pNext: ptr::null(),
                flags: vk::COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                queueFamilyIndex: 0,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result =
                self.vk.CreateCommandPool(self.device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        });

        let cb = self.cb.take().unwrap_or_else(|| unsafe {
            let info = vk::CommandBufferAllocateInfo {
                sType: vk::STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
                pNext: ptr::null(),
                commandPool: pool,
                level: vk::COMMAND_BUFFER_LEVEL_PRIMARY,
                commandBufferCount: 1,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result = self.vk.AllocateCommandBuffers(self.device, &info, output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        });

        let queue = self.queue.take().unwrap_or_else(|| unsafe {
            let mut output = mem::MaybeUninit::uninit();
            self.vk.GetDeviceQueue(self.device, 0, 0, output.as_mut_ptr());
            output.assume_init()
        });

        let fence = self.fence.take().unwrap_or_else(|| unsafe {
            let info = vk::FenceCreateInfo {
                sType: vk::STRUCTURE_TYPE_FENCE_CREATE_INFO,
                pNext: ptr::null(),
                flags: vk::FENCE_CREATE_SIGNALED_BIT,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result = self.vk.CreateFence(self.device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        });

        unsafe {
            const TIMEOUT_NS: u64 = 10_000_000_000; // 10 seconds
            let result = self.vk.WaitForFences(self.device, 1, &fence, vk::TRUE, TIMEOUT_NS);
            assert_eq!(result, vk::SUCCESS);
            let result = self.vk.ResetFences(self.device, 1, &fence);
            assert_eq!(result, vk::SUCCESS);

            let info = vk::CommandBufferBeginInfo {
                sType: vk::STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
                pNext: ptr::null(),
                flags: vk::COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
                pInheritanceInfo: ptr::null(),
            };
            let result = self.vk.BeginCommandBuffer(cb, &info);
            assert_eq!(result, vk::SUCCESS);

            let barrier = vk::ImageMemoryBarrier {
                sType: vk::STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                pNext: ptr::null(),
                srcAccessMask: self.access_mask,
                dstAccessMask: access_mask,
                oldLayout: self.layout,
                newLayout: new_layout,
                srcQueueFamilyIndex: 0,
                dstQueueFamilyIndex: 0,
                image: self.image,
                subresourceRange: vk::ImageSubresourceRange {
                    aspectMask: vk::IMAGE_ASPECT_COLOR_BIT,
                    baseMipLevel: 0,
                    levelCount: 1,
                    baseArrayLayer: 0,
                    layerCount: 1,
                },
            };
            self.vk.CmdPipelineBarrier(
                cb,
                self.stage,
                stage,
                0,
                0,
                ptr::null(),
                0,
                ptr::null(),
                1,
                &barrier,
            );

            let result = self.vk.EndCommandBuffer(cb);
            assert_eq!(result, vk::SUCCESS);

            let info = vk::SubmitInfo {
                sType: vk::STRUCTURE_TYPE_SUBMIT_INFO,
                pNext: ptr::null(),
                waitSemaphoreCount: 0,
                pWaitSemaphores: ptr::null(),
                pWaitDstStageMask: ptr::null(),
                commandBufferCount: 1,
                pCommandBuffers: &cb,
                signalSemaphoreCount: 0,
                pSignalSemaphores: ptr::null(),
            };
            let result = self.vk.QueueSubmit(queue, 1, &info, fence);
            assert_eq!(result, vk::SUCCESS);
        }

        self.layout = new_layout;
        self.stage = stage;
        self.access_mask = access_mask;

        // Cache pool, cb, queue and fence.
        self.pool = Some(pool);
        self.cb = Some(cb);
        self.queue = Some(queue);
        self.fence = Some(fence);
    }
}

impl Drop for VulkanImage {
    fn drop(&mut self) {
        unsafe {
            self.vk.DestroyImageView(self.device, self.view, ptr::null());
            self.vk.DestroySampler(self.device, self.sampler, ptr::null());
            self.vk.DestroyImage(self.device, self.image, ptr::null());
            self.vk.FreeMemory(self.device, self.memory, ptr::null());
        }
        if let Some(pool) = self.pool {
            unsafe {
                self.vk.DestroyCommandPool(self.device, pool, ptr::null());
            }
        }
        if let Some(fence) = self.fence {
            unsafe {
                self.vk.DestroyFence(self.device, fence, ptr::null());
            }
        }
    }
}

impl Image for VulkanImage {
    fn flush(&mut self) {}
}

const EXTERNAL_MEMORY_EXTENSION_NAME: &'static [u8; 27usize] = b"VK_FUCHSIA_external_memory\0";
const BUFFER_COLLECTION_EXTENSION_NAME: &'static [u8; 29usize] = b"VK_FUCHSIA_buffer_collection\0";

#[cfg(debug_assertions)]
const VALIDATION_LAYER_NAME: &'static [u8; 28usize] = b"VK_LAYER_KHRONOS_validation\0";

extern "C" fn image_dispatch_submitter(
    queue: vk::Queue,
    fence: vk::Fence,
    cb: vk::CommandBuffer,
    data: *const ::std::os::raw::c_void,
) {
    unsafe {
        // TODO: Add acquire and release semaphores.
        let info = vk::SubmitInfo {
            sType: vk::STRUCTURE_TYPE_SUBMIT_INFO,
            pNext: ptr::null(),
            waitSemaphoreCount: 0,
            pWaitSemaphores: ptr::null(),
            pWaitDstStageMask: ptr::null(),
            commandBufferCount: 1,
            pCommandBuffers: &cb,
            signalSemaphoreCount: 0,
            pSignalSemaphores: ptr::null(),
        };
        // Safe as images outlive the spinel context.
        let image_ptr = data as *const VulkanImage;
        let result = (*image_ptr).vk.QueueSubmit(queue, 1, &info, fence);
        assert_eq!(result, vk::SUCCESS);
    }
}

// Matches struct in copy.comp. See shader source for field descriptions.
#[repr(C)]
struct CopyParams {
    src_offset: [i32; 2], // ivec2 at 0  (8 byte aligned)
    dst_offset: [i32; 2], // ivec2 at 8  (8 byte aligned)
    dxdy: [i32; 2],       // ivec2 at 16 (8 byte aligned)
    extent: u32,          // uint  at 20 (4 byte aligned)
}

// Matches struct in motioncopy.comp. See shader source for field descriptions.
#[repr(C)]
struct MotionCopyParams {
    src_offset: [i32; 2], // ivec2 at 0  (8  byte aligned)
    src_dims: [i32; 2],   // ivec2 at 8  (8  byte aligned)
    dst_offset: [i32; 2], // ivec2 at 16 (8  byte aligned)
    dxdy: [i32; 2],       // ivec2 at 24 (8  byte aligned)
    border: [f32; 4],     // vec4  at 32 (16 byte aligned)
    exposure: u32,        // uint  at 48 (4  byte aligned)
    extent: u32,          // uint  at 52 (4  byte aligned)
}

struct VulkanShader {
    pipeline: vk::Pipeline,
    pipeline_layout: vk::PipelineLayout,
}

const DESCRIPTOR_SET_PRE_PROCESS: usize = 0;
const DESCRIPTOR_SET_POST_PROCESS: usize = 1;
const DESCRIPTOR_SET_COUNT: usize = 2;

struct VulkanContext {
    device: vk::Device,
    vk_i: vk::InstancePointers,
    vk: vk::DevicePointers,
    vk_ext: FuchsiaExtensionPointers,
    buffer_collection: BufferCollectionFUCHSIA,
    width: u32,
    height: u32,
    format: vk::Format,
    descriptor_pool: vk::DescriptorPool,
    descriptor_set_layout: vk::DescriptorSetLayout,
    descriptor_sets: Vec<vk::DescriptorSet>,
    copy_shader: Option<VulkanShader>,
    motioncopy_shader: Option<VulkanShader>,
}

pub struct SpinelContext {
    vulkan: VulkanContext,
    images: BTreeMap<u32, Box<VulkanImage>>,
    _environment: Box<SpnVkEnvironment>,
    context: Rc<RefCell<SpnContext>>,
    compositions: BTreeMap<u32, SpinelComposition>,
    styling: SpinelStyling,
    path_builder: SpinelPathBuilder,
    raster_builder: SpinelRasterBuilder,
    image_post_copy_regions: Vec<vk::ImageCopy>,
}

impl SpinelContext {
    fn create_shader(
        vk: &vk::DevicePointers,
        device: vk::Device,
        descriptor_set_layout: vk::DescriptorSetLayout,
        name: &str,
        constant_range_size: usize,
    ) -> VulkanShader {
        let pipeline_layout = unsafe {
            let constant_range = vk::PushConstantRange {
                stageFlags: vk::SHADER_STAGE_COMPUTE_BIT,
                offset: 0,
                size: constant_range_size as u32,
            };
            let info = vk::PipelineLayoutCreateInfo {
                sType: vk::STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                setLayoutCount: 1,
                pSetLayouts: &descriptor_set_layout,
                pushConstantRangeCount: 1,
                pPushConstantRanges: &constant_range,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreatePipelineLayout(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        // glslangValidator -V shaders/name.comp -o shaders/name-noopt.comp.spv
        // spirv-opt -O shaders/name-noopt.comp.spv -o shaders/name.comp.spv
        let shader = {
            let file_name = format!("/pkg/data/shaders/{}.comp.spv", name);
            let error_str = format!("Can't open file /pkg/data/shaders/{}.comp.spv", name);
            let mut file = File::open(file_name).expect(&error_str);
            let mut data = vec![];
            file.read_to_end(&mut data).unwrap();
            data
        };

        let shader_module = unsafe {
            let info = vk::ShaderModuleCreateInfo {
                sType: vk::STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                codeSize: shader.len(),
                pCode: shader.as_ptr() as *const u32,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateShaderModule(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let pipeline = unsafe {
            let info = vk::ComputePipelineCreateInfo {
                sType: vk::STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                stage: vk::PipelineShaderStageCreateInfo {
                    sType: vk::STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
                    pNext: ptr::null(),
                    flags: 0,
                    stage: vk::SHADER_STAGE_COMPUTE_BIT,
                    module: shader_module,
                    pName: b"main\0".as_ptr() as *const c_char,
                    pSpecializationInfo: ptr::null(),
                },
                layout: pipeline_layout,
                basePipelineHandle: 0,
                basePipelineIndex: 0,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result =
                vk.CreateComputePipelines(device, 0, 1, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        unsafe {
            vk.DestroyShaderModule(device, shader_module, ptr::null());
        }

        VulkanShader { pipeline, pipeline_layout }
    }

    fn update_descriptor_set(
        vk: &vk::DevicePointers,
        device: vk::Device,
        src_image: &VulkanImage,
        dst_image: &VulkanImage,
        descriptor_set: vk::DescriptorSet,
    ) {
        let src_image_info = vk::DescriptorImageInfo {
            sampler: src_image.sampler,
            imageView: src_image.view,
            imageLayout: vk::IMAGE_LAYOUT_GENERAL,
        };
        let dst_image_info = vk::DescriptorImageInfo {
            sampler: dst_image.sampler,
            imageView: dst_image.view,
            imageLayout: vk::IMAGE_LAYOUT_GENERAL,
        };
        let descriptor_set = [
            vk::WriteDescriptorSet {
                sType: vk::STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
                pNext: ptr::null(),
                dstSet: descriptor_set,
                dstBinding: 0,
                dstArrayElement: 0,
                descriptorCount: 1,
                descriptorType: vk::DESCRIPTOR_TYPE_STORAGE_IMAGE,
                pImageInfo: &src_image_info,
                pBufferInfo: ptr::null(),
                pTexelBufferView: ptr::null(),
            },
            vk::WriteDescriptorSet {
                sType: vk::STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
                pNext: ptr::null(),
                dstSet: descriptor_set,
                dstBinding: 1,
                dstArrayElement: 0,
                descriptorCount: 1,
                descriptorType: vk::DESCRIPTOR_TYPE_STORAGE_IMAGE,
                pImageInfo: &dst_image_info,
                pBufferInfo: ptr::null(),
                pTexelBufferView: ptr::null(),
            },
        ];
        unsafe {
            vk.UpdateDescriptorSets(
                device,
                descriptor_set.len() as u32,
                descriptor_set.as_ptr(),
                0,
                ptr::null(),
            );
        }
    }

    pub fn new(
        token: ClientEnd<BufferCollectionTokenMarker>,
        config: &fuchsia_framebuffer::Config,
        app_name: *const u8,
        block_pool_size: u64,
        handle_count: u32,
        layers_count: u32,
        cmds_count: u32,
    ) -> Self {
        let entry_points = {
            vk::EntryPoints::load(|name| unsafe {
                mem::transmute(vkGetInstanceProcAddr(0, name.as_ptr()))
            })
        };

        macro_rules! vulkan_version {
            ( $major:expr, $minor:expr, $patch:expr ) => {
                ($major as u32) << 22 | ($minor as u32) << 12 | ($patch as u32)
            };
        }

        let app_info = vk::ApplicationInfo {
            sType: vk::STRUCTURE_TYPE_APPLICATION_INFO,
            pNext: ptr::null(),
            pApplicationName: app_name as *const c_char,
            applicationVersion: 0,
            pEngineName: ptr::null(),
            engineVersion: 0,
            apiVersion: vulkan_version!(1, 1, 0),
        };
        #[cfg(debug_assertions)]
        let layers = vec![VALIDATION_LAYER_NAME.as_ptr() as *const c_char];
        #[cfg(not(debug_assertions))]
        let layers = Vec::new();
        let instance = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let create_info = vk::InstanceCreateInfo {
                sType: vk::STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                pApplicationInfo: &app_info,
                enabledLayerCount: layers.len() as u32,
                ppEnabledLayerNames: layers.as_ptr(),
                enabledExtensionCount: 0,
                ppEnabledExtensionNames: ptr::null(),
            };
            let result =
                entry_points.CreateInstance(&create_info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let vk_i = {
            vk::InstancePointers::load(|name| unsafe {
                mem::transmute(vkGetInstanceProcAddr(instance, name.as_ptr()))
            })
        };

        let physical_devices: Vec<vk::PhysicalDevice> = unsafe {
            let mut num = 0;
            let result = vk_i.EnumeratePhysicalDevices(instance, &mut num, ptr::null_mut());
            assert_eq!(result, vk::SUCCESS);

            let mut output = Vec::with_capacity(num as usize);
            let result = vk_i.EnumeratePhysicalDevices(instance, &mut num, output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.set_len(num as usize);
            output
        };
        assert_ne!(physical_devices.len(), 0);
        // TODO: Ability to select physical device.
        let physical_device = physical_devices[0];

        let pdmp = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            vk_i.GetPhysicalDeviceMemoryProperties(physical_device, output.as_mut_ptr());
            output.assume_init()
        };

        let pdp = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            vk_i.GetPhysicalDeviceProperties(physical_device, output.as_mut_ptr());
            output.assume_init()
        };

        println!(
            "{:X} : {:X} : {:?}",
            pdp.vendorID,
            pdp.deviceID,
            unsafe { CStr::from_ptr(pdp.deviceName.as_ptr()) }.to_str().unwrap()
        );

        let format = {
            macro_rules! format {
                ($var:tt) => {
                    (vk::$var, stringify!($var))
                };
            }
            static FORMATS: &'static [(vk::Format, &str)] =
                &[format!(FORMAT_B8G8R8A8_UNORM), format!(FORMAT_R8G8B8A8_UNORM)];

            let mut preferred_format = vk::FORMAT_UNDEFINED;
            let mut preferred_format_features = 0;

            for format in FORMATS {
                let properties = unsafe {
                    let mut output = mem::MaybeUninit::uninit();
                    vk_i.GetPhysicalDeviceFormatProperties(
                        physical_device,
                        format.0,
                        output.as_mut_ptr(),
                    );
                    output.assume_init()
                };

                // Storage is required.
                if properties.optimalTilingFeatures & vk::FORMAT_FEATURE_STORAGE_IMAGE_BIT == 0 {
                    continue;
                }
                if preferred_format == vk::FORMAT_UNDEFINED {
                    preferred_format = format.0;
                    preferred_format_features = properties.optimalTilingFeatures;
                }
                // Prefer formats that support sampling.
                if (properties.optimalTilingFeatures & vk::FORMAT_FEATURE_SAMPLED_IMAGE_BIT != 0)
                    && (preferred_format_features & vk::FORMAT_FEATURE_SAMPLED_IMAGE_BIT == 0)
                {
                    preferred_format = format.0;
                    preferred_format_features = properties.optimalTilingFeatures;
                }
                println!("{}{}", format.1, if preferred_format == format.0 { " *" } else { "" });
            }
            preferred_format
        };
        assert_ne!(format, vk::FORMAT_UNDEFINED);

        let (spn_target, hs_target) = unsafe {
            let mut spn_output = mem::MaybeUninit::uninit();
            let mut hs_output = mem::MaybeUninit::uninit();
            let status = spn_vk_find_target(
                pdp.vendorID,
                pdp.deviceID,
                spn_output.as_mut_ptr(),
                hs_output.as_mut_ptr(),
                ptr::null_mut(),
                0,
            );
            assert_eq!(status, true);
            (spn_output.assume_init(), hs_output.assume_init() as *mut _)
        };

        let mut spn_tr = unsafe {
            let mut output = mem::MaybeUninit::zeroed();
            let status = spn_vk_target_get_requirements(spn_target, output.as_mut_ptr());
            assert_eq!(status, SpnErrorPartialTargetRequirements);
            output.assume_init()
        };
        let mut hs_tr = unsafe {
            let mut output = mem::MaybeUninit::zeroed();
            let status = hotsort_vk_target_get_requirements(hs_target, output.as_mut_ptr());
            assert_eq!(status, false);
            output.assume_init()
        };
        let mut qcis = unsafe {
            let num = spn_tr.qci_count as usize;
            let mut output: Vec<vk::DeviceQueueCreateInfo> = Vec::with_capacity(num);
            output.set_len(num as usize);
            output
        };
        let mut ext_names = unsafe {
            let num = 2 + spn_tr.ext_name_count as usize + hs_tr.ext_name_count as usize;
            let mut output: Vec<*const c_char> = Vec::with_capacity(num);
            output.set_len(num as usize);
            output
        };
        ext_names[0] = EXTERNAL_MEMORY_EXTENSION_NAME.as_ptr() as *const c_char;
        ext_names[1] = BUFFER_COLLECTION_EXTENSION_NAME.as_ptr() as *const c_char;

        let mut feature1 = unsafe {
            let output = mem::MaybeUninit::<PhysicalDeviceHostQueryResetFeaturesEXT>::zeroed();
            output.assume_init()
        };
        feature1.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT;
        let mut feature2 = unsafe {
            let output =
                mem::MaybeUninit::<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::zeroed();
            output.assume_init()
        };
        feature2.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
        let mut feature3 = unsafe {
            let output = mem::MaybeUninit::<PhysicalDeviceScalarBlockLayoutFeaturesEXT>::zeroed();
            output.assume_init()
        };
        feature3.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT;
        let mut feature4 = unsafe {
            let output = mem::MaybeUninit::<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR>::zeroed();
            output.assume_init()
        };
        feature4.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR;
        let mut feature5 = unsafe {
            let output =
                mem::MaybeUninit::<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>::zeroed();
            output.assume_init()
        };
        feature5.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT;
        feature1.pNext = &mut feature2 as *mut _ as *mut c_void;
        feature2.pNext = &mut feature3 as *mut _ as *mut c_void;
        feature3.pNext = &mut feature4 as *mut _ as *mut c_void;
        feature4.pNext = &mut feature5 as *mut _ as *mut c_void;
        let mut pdf2 = unsafe {
            let output = mem::MaybeUninit::<PhysicalDeviceFeatures2>::zeroed();
            output.assume_init()
        };
        pdf2.sType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
        pdf2.pNext = &mut feature1 as *mut _ as *mut c_void;

        spn_tr.qcis = qcis.as_mut_ptr();
        spn_tr.ext_names =
            if spn_tr.ext_name_count > 0 { &mut ext_names[2] } else { ptr::null_mut() };
        spn_tr.pdf2 = &mut pdf2;
        unsafe {
            let status = spn_vk_target_get_requirements(spn_target, &mut spn_tr);
            assert_eq!(status, SpnSuccess);
        };
        hs_tr.ext_names = if hs_tr.ext_name_count > 0 {
            &mut ext_names[2 + spn_tr.ext_name_count as usize]
        } else {
            ptr::null_mut()
        };
        hs_tr.pdf = &mut pdf2.features;
        unsafe {
            let status = hotsort_vk_target_get_requirements(hs_target, &mut hs_tr);
            assert_eq!(status, true);
        };

        let device = unsafe {
            let info = vk::DeviceCreateInfo {
                sType: vk::STRUCTURE_TYPE_DEVICE_CREATE_INFO,
                pNext: pdf2.pNext,
                flags: 0,
                queueCreateInfoCount: qcis.len() as u32,
                pQueueCreateInfos: qcis.as_ptr(),
                enabledLayerCount: 0,
                ppEnabledLayerNames: ptr::null(),
                enabledExtensionCount: ext_names.len() as u32,
                ppEnabledExtensionNames: ext_names.as_ptr(),
                pEnabledFeatures: &pdf2.features,
            };

            let mut output = mem::MaybeUninit::uninit();
            let result =
                vk_i.CreateDevice(physical_device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };
        let vk = vk::DevicePointers::load(|name| unsafe {
            vk_i.GetDeviceProcAddr(device, name.as_ptr()) as *const _
        });

        let vk_ext = FuchsiaExtensionPointers::load(|name| unsafe {
            vk_i.GetDeviceProcAddr(device, name.as_ptr()) as *const _
        });

        let buffer_collection = unsafe {
            let info = BufferCollectionCreateInfoFUCHSIA {
                sType: STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
                pNext: ptr::null(),
                collectionToken: token.into_channel().into_raw(),
            };

            let mut output = mem::MaybeUninit::uninit();
            let result = vk_ext.CreateBufferCollectionFUCHSIA(
                device,
                &info,
                ptr::null(),
                output.as_mut_ptr(),
            );
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        unsafe {
            let info = VulkanImage::get_image_create_info(
                config.width,
                config.height,
                format,
                ptr::null(),
            );
            let result =
                vk_ext.SetBufferCollectionConstraintsFUCHSIA(device, buffer_collection, &info);
            assert_eq!(result, vk::SUCCESS);
        };

        let descriptor_pool = unsafe {
            let pool_size = vk::DescriptorPoolSize {
                ty: vk::DESCRIPTOR_TYPE_STORAGE_IMAGE,
                descriptorCount: 2 * DESCRIPTOR_SET_COUNT as u32,
            };
            let info = vk::DescriptorPoolCreateInfo {
                sType: vk::STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                maxSets: DESCRIPTOR_SET_COUNT as u32,
                poolSizeCount: 1,
                pPoolSizes: &pool_size,
            };
            let mut output = mem::MaybeUninit::uninit();
            let result = vk.CreateDescriptorPool(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let descriptor_set_layout = unsafe {
            let bindings = [
                vk::DescriptorSetLayoutBinding {
                    binding: 0,
                    descriptorType: vk::DESCRIPTOR_TYPE_STORAGE_IMAGE,
                    descriptorCount: 1,
                    stageFlags: vk::SHADER_STAGE_COMPUTE_BIT,
                    pImmutableSamplers: ptr::null(),
                },
                vk::DescriptorSetLayoutBinding {
                    binding: 1,
                    descriptorType: vk::DESCRIPTOR_TYPE_STORAGE_IMAGE,
                    descriptorCount: 1,
                    stageFlags: vk::SHADER_STAGE_COMPUTE_BIT,
                    pImmutableSamplers: ptr::null(),
                },
            ];
            let info = vk::DescriptorSetLayoutCreateInfo {
                sType: vk::STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                pNext: ptr::null(),
                flags: 0,
                bindingCount: bindings.len() as u32,
                pBindings: bindings.as_ptr(),
            };
            let mut output = mem::MaybeUninit::uninit();
            let result =
                vk.CreateDescriptorSetLayout(device, &info, ptr::null(), output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.assume_init()
        };

        let descriptor_sets = unsafe {
            let layouts = [descriptor_set_layout, descriptor_set_layout];
            let info = vk::DescriptorSetAllocateInfo {
                sType: vk::STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                pNext: ptr::null(),
                descriptorPool: descriptor_pool,
                descriptorSetCount: DESCRIPTOR_SET_COUNT as u32,
                pSetLayouts: layouts.as_ptr(),
            };
            let mut output = Vec::with_capacity(DESCRIPTOR_SET_COUNT);
            let result = vk.AllocateDescriptorSets(device, &info, output.as_mut_ptr());
            assert_eq!(result, vk::SUCCESS);
            output.set_len(DESCRIPTOR_SET_COUNT as usize);
            output
        };

        let mut environment = Box::new(SpnVkEnvironment {
            d: device,
            ac: ptr::null(),
            pc: 0,
            pd: physical_device,
            qfi: 0,
            pdmp: pdmp,
        });

        let create_info = SpnVkContextCreateInfo {
            block_pool_size,
            handle_count,
            spinel: spn_target,
            hotsort: hs_target,
        };

        let context = unsafe {
            let mut output = mem::MaybeUninit::uninit();
            let status =
                spn_vk_context_create(&mut *environment, &create_info, output.as_mut_ptr());
            assert_eq!(status, SpnSuccess);
            output.assume_init()
        };

        let context = Rc::new(RefCell::new(context));
        let styling = SpinelStyling::new(Rc::clone(&context), layers_count, cmds_count);
        let path_builder = SpinelPathBuilder::new(Rc::clone(&context));
        let raster_builder = SpinelRasterBuilder::new(Rc::clone(&context));

        Self {
            vulkan: VulkanContext {
                device,
                vk_i,
                vk,
                vk_ext,
                buffer_collection,
                width: config.width,
                height: config.height,
                format,
                descriptor_pool,
                descriptor_set_layout,
                descriptor_sets,
                copy_shader: None,
                motioncopy_shader: None,
            },
            images: BTreeMap::new(),
            _environment: environment,
            context,
            compositions: BTreeMap::new(),
            styling,
            path_builder,
            raster_builder,
            image_post_copy_regions: Vec::new(),
        }
    }
}

impl Drop for SpinelContext {
    fn drop(&mut self) {
        self.images.clear();
        unsafe {
            self.vulkan.vk_ext.DestroyBufferCollectionFUCHSIA(
                self.vulkan.device,
                self.vulkan.buffer_collection,
                ptr::null(),
            );
            self.vulkan.vk.FreeDescriptorSets(
                self.vulkan.device,
                self.vulkan.descriptor_pool,
                2,
                self.vulkan.descriptor_sets.as_ptr(),
            );
            self.vulkan.vk.DestroyDescriptorSetLayout(
                self.vulkan.device,
                self.vulkan.descriptor_set_layout,
                ptr::null(),
            );
            if let Some(shader) = self.vulkan.copy_shader.take() {
                self.vulkan.vk.DestroyPipeline(self.vulkan.device, shader.pipeline, ptr::null());
                self.vulkan.vk.DestroyPipelineLayout(
                    self.vulkan.device,
                    shader.pipeline_layout,
                    ptr::null(),
                );
            }
            if let Some(shader) = self.vulkan.motioncopy_shader.take() {
                self.vulkan.vk.DestroyPipeline(self.vulkan.device, shader.pipeline, ptr::null());
                self.vulkan.vk.DestroyPipelineLayout(
                    self.vulkan.device,
                    shader.pipeline_layout,
                    ptr::null(),
                );
            }
            self.vulkan.vk.DestroyDescriptorPool(
                self.vulkan.device,
                self.vulkan.descriptor_pool,
                ptr::null(),
            );
            self.vulkan.vk.DestroyDevice(self.vulkan.device, ptr::null());
        }
    }
}

impl Context for SpinelContext {
    fn get_pixel_format(&self) -> fuchsia_framebuffer::PixelFormat {
        match self.vulkan.format {
            vk::FORMAT_R8G8B8A8_UNORM => fuchsia_framebuffer::PixelFormat::BgrX888,
            _ => fuchsia_framebuffer::PixelFormat::RgbX888,
        }
    }

    fn styling(&mut self) -> &mut dyn Styling {
        &mut self.styling
    }

    fn path_builder(&mut self) -> &mut dyn PathBuilder {
        &mut self.path_builder
    }

    fn raster_builder(&mut self) -> &mut dyn RasterBuilder {
        &mut self.raster_builder
    }

    fn composition(&mut self, id: u32) -> &mut dyn Composition {
        let context = &self.context;
        self.compositions.entry(id).or_insert_with(|| SpinelComposition::new(Rc::clone(context)))
    }

    fn image(&mut self, id: u32, size: &[u32; 2]) -> &mut dyn Image {
        let vulkan = &self.vulkan;
        self.images
            .entry(id)
            .or_insert_with(|| {
                Box::new(VulkanImage::new(
                    vulkan.device,
                    &vulkan.vk_i,
                    size[0],
                    size[1],
                    vulkan.format,
                ))
            })
            .as_mut()
    }

    fn image_from_index(&mut self, id: u32, index: u32) -> &mut dyn Image {
        let vulkan = &self.vulkan;
        self.images
            .entry(id)
            .or_insert_with(|| {
                Box::new(VulkanImage::from_buffer_collection(
                    vulkan.device,
                    &vulkan.vk_i,
                    &vulkan.vk_ext,
                    vulkan.width,
                    vulkan.height,
                    vulkan.format,
                    vulkan.buffer_collection,
                    index,
                ))
            })
            .as_mut()
    }

    fn render(&mut self, image_id: u32, composition_id: u32, clip: &[u32; 4], exts: &[RenderExt]) {
        let mut pre_clear = None;
        let mut pre_copy = None;
        let mut post_copy = None;

        for ext in exts {
            match ext {
                RenderExt::PreClear(_) => {
                    pre_clear = Some(ext);
                }
                RenderExt::PreCopy(_) => {
                    pre_copy = Some(ext);
                }
                RenderExt::PostCopy(_) => {
                    post_copy = Some(ext);
                }
            }
        }

        let mut rs_image_pre_barrier = SpnVkRenderSubmitExtImagePreBarrier {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePreBarrier,
            old_layout: vk::IMAGE_LAYOUT_UNDEFINED,
            src_qfi: vk::QUEUE_FAMILY_IGNORED,
        };
        let mut rs_clear_color = vk::ClearColorValue { float32: [0.0; 4] };
        let mut rs_image_clear = SpnVkRenderSubmitExtImagePreClear {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePreClear,
            color: &rs_clear_color,
        };
        let mut rs_image_pre_process_params =
            CopyParams { src_offset: [0; 2], dst_offset: [0; 2], dxdy: [0; 2], extent: 0 };
        let mut rs_image_pre_process = SpnVkRenderSubmitExtImageProcess {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePreProcess,
            access_mask: vk::ACCESS_SHADER_READ_BIT | vk::ACCESS_SHADER_WRITE_BIT,
            pipeline: 0,
            pipeline_layout: 0,
            descriptor_set_count: 0,
            descriptor_sets: ptr::null(),
            push_offset: 0,
            push_size: mem::size_of::<CopyParams>() as u32,
            push_values: &rs_image_pre_process_params as *const _ as *const c_void,
            group_count_x: 1,
            group_count_y: 1,
            group_count_z: 1,
        };
        let mut rs_image_post_process_params = MotionCopyParams {
            src_offset: [0; 2],
            src_dims: [0; 2],
            dst_offset: [0; 2],
            dxdy: [0; 2],
            border: [0.0; 4],
            exposure: 0,
            extent: 0,
        };
        let mut rs_image_post_process = SpnVkRenderSubmitExtImageProcess {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePostProcess,
            access_mask: vk::ACCESS_SHADER_READ_BIT,
            pipeline: 0,
            pipeline_layout: 0,
            descriptor_set_count: 0,
            descriptor_sets: ptr::null(),
            push_offset: 0,
            push_size: mem::size_of::<MotionCopyParams>() as u32,
            push_values: &rs_image_post_process_params as *const _ as *const c_void,
            group_count_x: 1,
            group_count_y: 1,
            group_count_z: 1,
        };
        let mut rs_image_post_copy = SpnVkRenderSubmitExtImagePostCopyToImage {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePostCopyToImage,
            dst: 0,
            dst_layout: vk::IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
            region_count: 0,
            regions: ptr::null(),
        };
        let mut rs_image_post_barrier = SpnVkRenderSubmitExtImagePostBarrier {
            ext: ptr::null_mut(),
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImagePostBarrier,
            new_layout: vk::IMAGE_LAYOUT_UNDEFINED,
            dst_qfi: vk::QUEUE_FAMILY_IGNORED,
        };
        let mut rs_image_ext = ptr::null_mut();
        let mut post_image_layout = vk::IMAGE_LAYOUT_PRESENT_SRC_KHR;

        let image = self.images.get(&image_id).expect("invalid image");
        if image.layout != vk::IMAGE_LAYOUT_GENERAL {
            rs_image_pre_barrier.old_layout = image.layout;
            rs_image_pre_barrier.ext = rs_image_ext;
            rs_image_ext = &mut rs_image_pre_barrier as *mut _ as *mut c_void;
        }

        if let Some(RenderExt::PreClear(color)) = pre_clear {
            rs_clear_color.float32 = *color;
            rs_image_clear.ext = rs_image_ext;
            rs_image_ext = &mut rs_image_clear as *mut _ as *mut c_void;
        }

        if let Some(RenderExt::PreCopy((src, region))) = pre_copy {
            let vk = &self.vulkan.vk;
            let device = self.vulkan.device;
            let descriptor_set_layout = self.vulkan.descriptor_set_layout;
            let copy_shader = self.vulkan.copy_shader.get_or_insert_with(|| {
                Self::create_shader(
                    vk,
                    device,
                    descriptor_set_layout,
                    "copy",
                    mem::size_of::<CopyParams>(),
                )
            });
            rs_image_pre_process.pipeline = copy_shader.pipeline;
            rs_image_pre_process.pipeline_layout = copy_shader.pipeline_layout;
            let src_image = self.images.get(&src).expect("invalid image");
            let dst_image = self.images.get(&image_id).expect("invalid image");
            Self::update_descriptor_set(
                vk,
                device,
                src_image,
                dst_image,
                self.vulkan.descriptor_sets[DESCRIPTOR_SET_PRE_PROCESS],
            );
            rs_image_pre_process.descriptor_set_count = 1;
            rs_image_pre_process.descriptor_sets =
                &self.vulkan.descriptor_sets[DESCRIPTOR_SET_PRE_PROCESS];

            // TODO: Combined X+Y offset support.
            if region.dst_offset[0] != region.src_offset[0]
                && region.dst_offset[1] != region.src_offset[1]
            {
                panic!("dst/src X and dst/src Y offset cannot both change");
            }

            let mut extent = None;
            let mut groups = 0;
            for i in 0..2 {
                match region.dst_offset[i] as i32 - region.src_offset[i] as i32 {
                    std::i32::MIN..=-1 => {
                        // Copy forward.
                        rs_image_pre_process_params.src_offset[i] = region.src_offset[i] as i32;
                        rs_image_pre_process_params.dst_offset[i] = region.dst_offset[i] as i32;
                        rs_image_pre_process_params.dxdy[i] = 1;
                        extent = Some(region.extent[i]);
                    }
                    0 => {
                        // Copy direction is not important.
                        rs_image_pre_process_params.src_offset[i] = region.src_offset[i] as i32;
                        rs_image_pre_process_params.dst_offset[i] = region.dst_offset[i] as i32;
                        rs_image_pre_process_params.dxdy[i] = 0;
                        groups = region.extent[i];
                    }
                    1..=std::i32::MAX => {
                        // Copy backwards.
                        rs_image_pre_process_params.src_offset[i] =
                            (region.src_offset[i] + region.extent[i]) as i32 - 1;
                        rs_image_pre_process_params.dst_offset[i] =
                            (region.dst_offset[i] + region.extent[i]) as i32 - 1;
                        rs_image_pre_process_params.dxdy[i] = -1;
                        extent = Some(region.extent[i]);
                    }
                }
            }

            let extent = extent.unwrap_or_else(|| {
                // Copy rows forward if direction is not important for either dimension.
                rs_image_pre_process_params.dxdy[0] = 1;
                groups = region.extent[1];
                region.extent[0]
            });

            rs_image_pre_process_params.extent = extent;
            const LOCAL_SIZE_X: u32 = 48;
            // TODO: Clip output to extent instead of rounding up.
            rs_image_pre_process.group_count_x = (groups + LOCAL_SIZE_X - 1) / LOCAL_SIZE_X;
            rs_image_pre_process.ext = rs_image_ext;
            rs_image_ext = &mut rs_image_pre_process as *mut _ as *mut c_void;
        }

        if let Some(RenderExt::PostCopy((dst, border, exposure, region))) = post_copy {
            if *dst == image_id {
                panic!("dst image must be different from the render image")
            }
            // Use motion copy shader if exposure amount is larger than 1.
            if exposure[0].abs() > 1 || exposure[1].abs() > 1 {
                let vk = &self.vulkan.vk;
                let device = self.vulkan.device;
                let descriptor_set_layout = self.vulkan.descriptor_set_layout;
                let motioncopy_shader = self.vulkan.motioncopy_shader.get_or_insert_with(|| {
                    Self::create_shader(
                        vk,
                        device,
                        descriptor_set_layout,
                        "motioncopy",
                        mem::size_of::<MotionCopyParams>(),
                    )
                });
                rs_image_post_process.pipeline = motioncopy_shader.pipeline;
                rs_image_post_process.pipeline_layout = motioncopy_shader.pipeline_layout;
                let dst_image = self.images.get_mut(&dst).expect("invalid image");
                if dst_image.layout != vk::IMAGE_LAYOUT_GENERAL {
                    dst_image.layout_transition(
                        vk::IMAGE_LAYOUT_GENERAL,
                        vk::PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                        vk::ACCESS_SHADER_WRITE_BIT,
                    );
                }
                let src_image = self.images.get(&image_id).expect("invalid image");
                let dst_image = self.images.get(&dst).expect("invalid image");
                Self::update_descriptor_set(
                    vk,
                    device,
                    src_image,
                    dst_image,
                    self.vulkan.descriptor_sets[DESCRIPTOR_SET_POST_PROCESS],
                );
                rs_image_post_process.descriptor_set_count = 1;
                rs_image_post_process.descriptor_sets =
                    &self.vulkan.descriptor_sets[DESCRIPTOR_SET_POST_PROCESS];

                // TODO: Combined X+Y exposure support.
                if exposure[0] != 0 && exposure[1] != 0 {
                    panic!("X and Y exposure cannot be used at the same time");
                }

                let mut extent = None;
                let mut groups = 0;
                for i in 0..2 {
                    match exposure[i] {
                        std::i32::MIN..=-1 => {
                            // Copy forward.
                            rs_image_post_process_params.src_offset[i] =
                                region.src_offset[i] as i32;
                            rs_image_post_process_params.dst_offset[i] =
                                region.dst_offset[i] as i32;
                            rs_image_post_process_params.dxdy[i] = 1;
                            extent = Some(region.extent[i]);
                        }
                        0 => {
                            // Copy direction is not important.
                            rs_image_post_process_params.src_offset[i] =
                                region.src_offset[i] as i32;
                            rs_image_post_process_params.dst_offset[i] =
                                region.dst_offset[i] as i32;
                            rs_image_post_process_params.dxdy[i] = 0;
                            groups = region.extent[i];
                        }
                        1..=std::i32::MAX => {
                            // Copy backwards.
                            rs_image_post_process_params.src_offset[i] =
                                (region.src_offset[i] + region.extent[i]) as i32 - 1;
                            rs_image_post_process_params.dst_offset[i] =
                                (region.dst_offset[i] + region.extent[i]) as i32 - 1;
                            rs_image_post_process_params.dxdy[i] = -1;
                            extent = Some(region.extent[i]);
                        }
                    }
                }

                let extent = extent.unwrap_or_else(|| {
                    // Copy rows forward if direction is not important for either dimension.
                    rs_image_post_process_params.dxdy[0] = 1;
                    groups = region.extent[1];
                    region.extent[0]
                });
                let exposure_amount = extent.min((exposure[0].abs() + exposure[1].abs()) as u32);

                rs_image_post_process_params.exposure = exposure_amount;
                rs_image_post_process_params.extent = extent - exposure_amount;
                rs_image_post_process_params.src_dims =
                    [src_image.width as i32, src_image.height as i32];
                rs_image_post_process_params.border = *border;
                const LOCAL_SIZE_X: u32 = 48;
                // TODO: Clip output to extent instead of rounding up.
                rs_image_post_process.group_count_x = (groups + LOCAL_SIZE_X - 1) / LOCAL_SIZE_X;
                rs_image_post_process.ext = rs_image_ext;
                rs_image_ext = &mut rs_image_post_process as *mut _ as *mut c_void;
            } else {
                let src_image = self.images.get(&image_id).expect("invalid image");
                let mut src_y = region.src_offset[1];
                let mut dst_y = region.dst_offset[1];
                let mut height = region.extent[1];
                self.image_post_copy_regions.clear();
                while height > 0 {
                    let rows = height.min(src_image.height - src_y);
                    let mut width = region.extent[0];
                    let mut src_x = region.src_offset[0];
                    let mut dst_x = region.dst_offset[0];
                    while width > 0 {
                        let columns = width.min(src_image.width - src_x);
                        self.image_post_copy_regions.push(vk::ImageCopy {
                            srcSubresource: vk::ImageSubresourceLayers {
                                aspectMask: vk::IMAGE_ASPECT_COLOR_BIT,
                                mipLevel: 0,
                                baseArrayLayer: 0,
                                layerCount: 1,
                            },
                            srcOffset: vk::Offset3D { x: src_x as i32, y: src_y as i32, z: 0 },
                            dstSubresource: vk::ImageSubresourceLayers {
                                aspectMask: vk::IMAGE_ASPECT_COLOR_BIT,
                                mipLevel: 0,
                                baseArrayLayer: 0,
                                layerCount: 1,
                            },
                            dstOffset: vk::Offset3D { x: dst_x as i32, y: dst_y as i32, z: 0 },
                            extent: vk::Extent3D { width: columns, height: rows, depth: 1 },
                        });
                        width -= columns;
                        dst_x += columns;
                        src_x = 0;
                    }
                    height -= rows;
                    dst_y += rows;
                    src_y = 0;
                }
                let dst_image = self.images.get_mut(&dst).expect("invalid image");
                if dst_image.layout != vk::IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL {
                    dst_image.layout_transition(
                        vk::IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                        vk::PIPELINE_STAGE_TRANSFER_BIT,
                        vk::ACCESS_TRANSFER_WRITE_BIT,
                    );
                }
                rs_image_post_copy.region_count = self.image_post_copy_regions.len() as u32;
                rs_image_post_copy.regions = self.image_post_copy_regions.as_ptr();
                rs_image_post_copy.dst = dst_image.image;
                rs_image_post_copy.ext = rs_image_ext;
                rs_image_ext = &mut rs_image_post_copy as *mut _ as *mut c_void;
            }
            post_image_layout = vk::IMAGE_LAYOUT_GENERAL;
        }

        let image = self.images.get_mut(&image_id).expect("invalid image");
        if post_image_layout != vk::IMAGE_LAYOUT_GENERAL {
            rs_image_post_barrier.new_layout = post_image_layout;
            rs_image_post_barrier.ext = rs_image_ext;
            rs_image_ext = &mut rs_image_post_barrier as *mut _ as *mut c_void;
        }
        image.layout = post_image_layout;

        let mut rs_image = SpnVkRenderSubmitExtImageRender {
            ext: rs_image_ext,
            type_: SpnVkRenderSubmitExtType::SpnVkRenderSubmitExtTypeImageRender,
            image: image.image,
            image_info: vk::DescriptorImageInfo {
                sampler: image.sampler,
                imageView: image.view,
                imageLayout: vk::IMAGE_LAYOUT_GENERAL,
            },
            submitter_pfn: image_dispatch_submitter,
            // Safe as image outlive context.
            submitter_data: image as &mut VulkanImage as *mut _ as *mut c_void,
        };
        let composition = self.compositions.get(&composition_id).expect("invalid composition");
        let rs = SpnRenderSubmit {
            ext: &mut rs_image as *mut _ as *mut c_void,
            styling: self.styling.styling,
            composition: composition.composition,
            clip: *clip,
        };
        let status = unsafe { spn_render(*self.context.borrow(), &rs) };
        assert_eq!(status, SpnSuccess);

        // Unsealing the composition will block until rendering has completed.
        // TODO(reveman): Use fence instead of blocking.
        unsafe {
            let status = spn_composition_unseal(composition.composition);
            assert_eq!(status, SpnSuccess);
        }
    }
}

//
// Mold Implementation
//

struct MoldPathBuilder {
    path_builder: spinel_mold::PathBuilder,
}

impl MoldPathBuilder {
    fn new() -> Self {
        Self { path_builder: spinel_mold::PathBuilder::new() }
    }
}

impl PathBuilder for MoldPathBuilder {
    fn begin(&mut self) {}

    fn end(&mut self) -> Path {
        Path::Mold(self.path_builder.build())
    }

    fn move_to(&mut self, p: &Point) {
        self.path_builder.move_to(p.x, p.y);
    }

    fn line_to(&mut self, p: &Point) {
        self.path_builder.line_to(p.x, p.y);
    }
}

struct MoldRasterBuilder {
    raster_builder: spinel_mold::RasterBuilder,
}

impl MoldRasterBuilder {
    fn new() -> Self {
        Self { raster_builder: spinel_mold::RasterBuilder::new() }
    }
}

impl RasterBuilder for MoldRasterBuilder {
    fn begin(&mut self) {}

    fn end(&mut self) -> Raster {
        Raster::Mold(self.raster_builder.build())
    }

    fn add(&mut self, path: &Path, transform: &Transform2D<f32>, _clip: &[f32; 4]) {
        let transform: [f32; 9] = [
            transform.m11,
            transform.m21,
            transform.m31,
            transform.m12,
            transform.m22,
            transform.m32,
            0.0,
            0.0,
            1.0,
        ];
        match path {
            Path::Mold(path) => self.raster_builder.push_path(path.clone(), &transform),
            _ => {
                panic!("bad path");
            }
        }
    }
}

struct MoldStyling {
    styling: spinel_mold::Styling,
}

impl MoldStyling {
    fn new() -> Self {
        Self { styling: spinel_mold::Styling::new() }
    }
}

impl Styling for MoldStyling {
    fn seal(&mut self) {}

    fn unseal(&mut self) {}

    fn reset(&mut self) {
        self.styling.reset();
    }

    fn alloc_group(
        &mut self,
        range_lo: u32,
        range_hi: u32,
        background_color: &[f32; 4],
    ) -> GroupId {
        let group_id = self.styling.group_alloc();
        self.styling.group_range_lo(group_id, range_lo);
        self.styling.group_range_hi(group_id, range_hi);

        let cmds_enter = self.styling.group_enter(group_id, 1);
        unsafe {
            cmds_enter.write(spinel_mold::SPN_STYLING_OPCODE_COLOR_ACC_ZERO);
        }

        let mut cmds_leave = self.styling.group_leave(group_id, 4);
        let mut bytes = [0u8; 4];
        for i in 0..4 {
            bytes[i] = u8::try_from((background_color[i] * 255.0).round() as u32)
                .expect("RGBA colors must be between 0.0 and 1.0");
        }
        unsafe {
            cmds_leave.write(spinel_mold::SPN_STYLING_OPCODE_COLOR_ACC_OVER_BACKGROUND);
            cmds_leave = cmds_leave.add(1);
            cmds_leave.write(u32::from_be_bytes(bytes));
            cmds_leave = cmds_leave.add(1);
            cmds_leave.write(0);
            cmds_leave = cmds_leave.add(1);
            cmds_leave.write(spinel_mold::SPN_STYLING_OPCODE_COLOR_ACC_STORE_TO_SURFACE);
        }

        GroupId::Mold(group_id)
    }

    fn group_layer(&mut self, group_id: &GroupId, layer_id: u32, color: &[f32; 4]) {
        let group_id = match group_id {
            GroupId::Mold(id) => *id,
            _ => panic!("invalid group id"),
        };
        let mut cmds = self.styling.layer(group_id, layer_id, 6);
        unsafe {
            cmds.write(spinel_mold::SPN_STYLING_OPCODE_COVER_WIP_ZERO);
            cmds = cmds.add(1);
            cmds.write(spinel_mold::SPN_STYLING_OPCODE_COVER_NONZERO);
            cmds = cmds.add(1);
        }
        let mut bytes = [0u8; 4];
        for i in 0..4 {
            bytes[i] = u8::try_from((color[i] * 255.0).round() as u32)
                .expect("RGBA colors must be between 0.0 and 1.0");
        }
        unsafe {
            cmds.write(spinel_mold::SPN_STYLING_OPCODE_COLOR_FILL_SOLID);
            cmds = cmds.add(1);
            cmds.write(u32::from_be_bytes(bytes));
            cmds = cmds.add(1);
            cmds.write(0);
            cmds = cmds.add(1);
            cmds.write(spinel_mold::SPN_STYLING_OPCODE_BLEND_OVER);
        }
    }
}

struct MoldComposition {
    composition: spinel_mold::Composition,
}

impl MoldComposition {
    fn new() -> Self {
        Self { composition: spinel_mold::Composition::new() }
    }
}

impl Composition for MoldComposition {
    fn seal(&mut self) {}

    fn unseal(&mut self) {}

    fn reset(&mut self) {
        self.composition.reset();
    }

    fn set_clip(&mut self, _clip: &[u32; 4]) {}

    fn place(&mut self, raster: &Raster, layer_id: u32) {
        match raster {
            Raster::Mold(raster) => {
                self.composition.place(layer_id, raster.clone());
            }
            _ => {
                panic!("bad raster");
            }
        }
    }
}

#[derive(Clone)]
struct MoldColorBuffer {
    mapping: Arc<mapped_vmo::Mapping>,
    stride: usize,
}

impl mold::ColorBuffer for MoldColorBuffer {
    fn pixel_format(&self) -> mold::PixelFormat {
        mold::PixelFormat::BGRA8888
    }

    fn stride(&self) -> usize {
        self.stride
    }

    unsafe fn write_at(&mut self, offset: usize, src: *const u8, len: usize) {
        self.mapping.write_at(offset, std::slice::from_raw_parts(src, len));
    }
}

struct MoldImage {
    vmo: zx::Vmo,
    width: u32,
    height: u32,
    size_bytes: u64,
    color_buffer: MoldColorBuffer,
    map: Option<mold::tile::Map>,
    old_prints: HashSet<u32>,
    new_prints: HashSet<u32>,
}

impl MoldImage {
    fn new(width: u32, height: u32) -> Self {
        let size_bytes = width * height * 4;
        let (mapping, vmo) =
            mapped_vmo::Mapping::allocate(size_bytes as usize).expect("Mapping::allocate");

        MoldImage {
            vmo,
            width,
            height,
            size_bytes: size_bytes as u64,
            color_buffer: MoldColorBuffer { mapping: Arc::new(mapping), stride: width as usize },
            map: None,
            old_prints: HashSet::new(),
            new_prints: HashSet::new(),
        }
    }

    fn from_buffer_collection(
        buffer_collection: &mut BufferCollectionSynchronousProxy,
        index: u32,
        width: u32,
        height: u32,
    ) -> Self {
        let (status, buffers) = buffer_collection
            .wait_for_buffers_allocated(zx::Time::after(10.second()))
            .expect("wait_for_buffers_allocated");
        assert_eq!(status, zx::sys::ZX_OK);

        let vmo_buffer = &buffers.buffers[index as usize];
        let vmo = vmo_buffer
            .vmo
            .as_ref()
            .expect("vmo_buffer")
            .duplicate_handle(zx::Rights::SAME_RIGHTS)
            .expect("duplicating buffer vmo");

        let size_bytes = buffers.settings.buffer_settings.size_bytes;
        let mapping = Arc::new(
            mapped_vmo::Mapping::create_from_vmo(
                &vmo,
                size_bytes as usize,
                zx::VmarFlags::PERM_READ
                    | zx::VmarFlags::PERM_WRITE
                    | zx::VmarFlags::MAP_RANGE
                    | zx::VmarFlags::REQUIRE_NON_RESIZABLE,
            )
            .expect("Mapping::create_from_vmo"),
        );

        assert_eq!(buffers.settings.has_image_format_constraints, true);
        let bytes_per_row = buffers.settings.image_format_constraints.min_bytes_per_row;
        let divisor = buffers.settings.image_format_constraints.bytes_per_row_divisor;
        let bytes_per_row = ((bytes_per_row + divisor - 1) / divisor) * divisor;

        MoldImage {
            vmo,
            width,
            height,
            size_bytes: size_bytes as u64,
            color_buffer: MoldColorBuffer { mapping, stride: (bytes_per_row / 4) as usize },
            map: None,
            old_prints: HashSet::new(),
            new_prints: HashSet::new(),
        }
    }
}

impl Image for MoldImage {
    fn flush(&mut self) {
        self.vmo
            .op_range(zx::VmoOp::CACHE_CLEAN_INVALIDATE, 0, self.size_bytes)
            .expect("cache clean");
    }
}

pub struct MoldContext {
    buffer_collection: BufferCollectionSynchronousProxy,
    size: [u32; 2],
    images: BTreeMap<u32, MoldImage>,
    compositions: BTreeMap<u32, MoldComposition>,
    styling: MoldStyling,
    path_builder: MoldPathBuilder,
    raster_builder: MoldRasterBuilder,
}

impl MoldContext {
    fn linear_image_format_constraints(width: u32, height: u32) -> ImageFormatConstraints {
        ImageFormatConstraints {
            pixel_format: SysmemPixelFormat {
                type_: PixelFormatType::Bgra32,
                has_format_modifier: true,
                format_modifier: FormatModifier { value: FORMAT_MODIFIER_LINEAR },
            },
            color_spaces_count: 1,
            color_space: [ColorSpace { type_: ColorSpaceType::Srgb }; 32],
            min_coded_width: width,
            max_coded_width: std::u32::MAX,
            min_coded_height: height,
            max_coded_height: std::u32::MAX,
            min_bytes_per_row: width * 4,
            max_bytes_per_row: std::u32::MAX,
            max_coded_width_times_coded_height: std::u32::MAX,
            layers: 1,
            coded_width_divisor: 1,
            coded_height_divisor: 1,
            bytes_per_row_divisor: 4,
            start_offset_divisor: 1,
            display_width_divisor: 1,
            display_height_divisor: 1,
            required_min_coded_width: 0,
            required_max_coded_width: 0,
            required_min_coded_height: 0,
            required_max_coded_height: 0,
            required_min_bytes_per_row: 0,
            required_max_bytes_per_row: 0,
        }
    }

    fn buffer_memory_constraints(width: u32, height: u32) -> BufferMemoryConstraints {
        BufferMemoryConstraints {
            min_size_bytes: width * height * 4,
            max_size_bytes: std::u32::MAX,
            physically_contiguous_required: false,
            secure_required: false,
            ram_domain_supported: true,
            cpu_domain_supported: true,
            inaccessible_domain_supported: false,
            heap_permitted_count: 1,
            heap_permitted: [HeapType::SystemRam; 32],
        }
    }

    fn buffer_collection_constraints(width: u32, height: u32) -> BufferCollectionConstraints {
        BufferCollectionConstraints {
            usage: BufferUsage {
                none: 0,
                cpu: CPU_USAGE_WRITE_OFTEN,
                vulkan: 0,
                display: 0,
                video: 0,
            },
            min_buffer_count_for_camping: 0,
            min_buffer_count_for_dedicated_slack: 0,
            min_buffer_count_for_shared_slack: 0,
            min_buffer_count: 1,
            max_buffer_count: std::u32::MAX,
            has_buffer_memory_constraints: true,
            buffer_memory_constraints: Self::buffer_memory_constraints(width, height),
            image_format_constraints_count: 1,
            image_format_constraints: [Self::linear_image_format_constraints(width, height); 32],
        }
    }

    pub fn new(
        token: ClientEnd<BufferCollectionTokenMarker>,
        config: &fuchsia_framebuffer::Config,
    ) -> Self {
        let sysmem = connect_to_service::<AllocatorMarker>().unwrap();
        let (collection_client, collection_request) = zx::Channel::create().unwrap();
        sysmem
            .bind_shared_collection(
                ClientEnd::new(token.into_channel()),
                ServerEnd::new(collection_request),
            )
            .unwrap();
        let mut buffer_collection = BufferCollectionSynchronousProxy::new(collection_client);
        let mut constraints = Self::buffer_collection_constraints(config.width, config.height);
        buffer_collection
            .set_constraints(true, &mut constraints)
            .expect("Sending buffer constraints to sysmem");

        Self {
            buffer_collection,
            size: [config.width, config.height],
            images: BTreeMap::new(),
            compositions: BTreeMap::new(),
            styling: MoldStyling::new(),
            path_builder: MoldPathBuilder::new(),
            raster_builder: MoldRasterBuilder::new(),
        }
    }

    fn copy_region(
        src_ptr: *mut u8,
        src_width: usize,
        src_height: usize,
        src_bytes_per_row: usize,
        dst_ptr: *mut u8,
        dst_len: usize,
        dst_bytes_per_row: usize,
        region: &CopyRegion,
    ) {
        let (mut y, dy) = if region.dst_offset[1] < region.src_offset[1] {
            // Copy forward.
            (0, 1)
        } else {
            // Copy backwards.
            (region.extent[1] as i32 - 1, -1)
        };
        let mut extent = region.extent[1];
        while extent > 0 {
            let src_y = (region.src_offset[1] + y as u32) % src_height as u32;
            let dst_y = region.dst_offset[1] + y as u32;
            let mut src_x = region.src_offset[0] as usize;
            let mut dst_x = region.dst_offset[0] as usize;
            let mut width = region.extent[0] as usize;
            while width > 0 {
                let columns = width.min(src_width - src_x);
                let src_offset = src_y as usize * src_bytes_per_row + src_x * 4;
                let dst_offset = dst_y as usize * dst_bytes_per_row + dst_x * 4;
                assert!((dst_offset + dst_bytes_per_row) <= dst_len);
                let src = (src_ptr as usize).checked_add(src_offset).unwrap() as *mut u8;
                let dst = (dst_ptr as usize).checked_add(dst_offset).unwrap() as *mut u8;
                unsafe {
                    ptr::copy(src, dst, (columns * 4) as usize);
                }
                width -= columns;
                dst_x += columns;
                src_x = 0;
            }
            y += dy;
            extent -= 1;
        }
    }
}

impl Context for MoldContext {
    fn get_pixel_format(&self) -> fuchsia_framebuffer::PixelFormat {
        fuchsia_framebuffer::PixelFormat::RgbX888
    }

    fn styling(&mut self) -> &mut dyn Styling {
        &mut self.styling
    }

    fn path_builder(&mut self) -> &mut dyn PathBuilder {
        &mut self.path_builder
    }

    fn raster_builder(&mut self) -> &mut dyn RasterBuilder {
        &mut self.raster_builder
    }

    fn composition(&mut self, id: u32) -> &mut dyn Composition {
        self.compositions.entry(id).or_insert_with(|| MoldComposition::new())
    }

    fn image(&mut self, id: u32, size: &[u32; 2]) -> &mut dyn Image {
        self.images.entry(id).or_insert_with(|| MoldImage::new(size[0], size[1]))
    }

    fn image_from_index(&mut self, id: u32, index: u32) -> &mut dyn Image {
        let buffer_collection = &mut self.buffer_collection;
        let width = self.size[0];
        let height = self.size[1];
        self.images.entry(id).or_insert_with(|| {
            MoldImage::from_buffer_collection(buffer_collection, index, width, height)
        })
    }

    fn render(&mut self, image_id: u32, composition_id: u32, clip: &[u32; 4], exts: &[RenderExt]) {
        let mut pre_clear = None;
        let mut pre_copy = None;
        let mut post_copy = None;

        for ext in exts {
            match ext {
                RenderExt::PreClear(_) => {
                    pre_clear = Some(ext);
                }
                RenderExt::PreCopy(_) => {
                    pre_copy = Some(ext);
                }
                RenderExt::PostCopy(_) => {
                    post_copy = Some(ext);
                }
            }
        }

        let width = self.size[0] as usize;
        let height = self.size[1] as usize;
        let image = self.images.get_mut(&image_id).expect("invalid image");
        let mut map = image
            .map
            .take()
            .filter(|map| map.width() == width && map.height() == height)
            .unwrap_or_else(|| mold::tile::Map::new(width, height));

        if let Some(RenderExt::PreClear(color)) = pre_clear {
            let (ptr, _) = Arc::get_mut(&mut image.color_buffer.mapping).unwrap().as_ptr_len();
            let bgra = [color[2], color[1], color[0], color[3]];
            let mut bytes = [0u8; 4];
            for i in 0..4 {
                bytes[i] = u8::try_from((bgra[i] * 255.0).round() as u32)
                    .expect("RGBA colors must be between 0.0 and 1.0");
            }
            for i in (0..image.size_bytes).step_by(4) {
                let dst = (ptr as usize).checked_add(i as usize).unwrap() as *mut u8;
                unsafe {
                    ptr::copy_nonoverlapping(bytes.as_mut_ptr(), dst, 4);
                }
            }
            for id in image.old_prints.drain() {
                map.remove(id);
            }
        }

        if let Some(RenderExt::PreCopy((src, region))) = pre_copy {
            let src_image = self.images.get_mut(src).expect("invalid image");
            let (src_ptr, _) =
                Arc::get_mut(&mut src_image.color_buffer.mapping).unwrap().as_ptr_len();
            let src_bytes_per_row = src_image.color_buffer.stride * 4;
            let src_width = src_image.width as usize;
            let src_height = src_image.height as usize;
            let dst_image = self.images.get_mut(&image_id).expect("invalid image");
            let (dst_ptr, dst_len) =
                Arc::get_mut(&mut dst_image.color_buffer.mapping).unwrap().as_ptr_len();
            let dst_bytes_per_row = dst_image.color_buffer.stride * 4;
            Self::copy_region(
                src_ptr,
                src_width,
                src_height,
                src_bytes_per_row,
                dst_ptr,
                dst_len as usize,
                dst_bytes_per_row,
                region,
            );
        }

        map.set_clip(Some(mold::Clip {
            x: clip[0] as usize,
            y: clip[1] as usize,
            width: (clip[2] - clip[0]) as usize,
            height: (clip[3] - clip[1]) as usize,
        }));

        let image = self.images.get_mut(&image_id).expect("invalid image");
        let composition = self.compositions.get_mut(&composition_id).expect("invalid composition");
        self.styling.styling.prints(&mut composition.composition, &mut map, &mut image.new_prints);

        for &id in image.old_prints.difference(&image.new_prints) {
            map.remove(id);
        }
        image.old_prints.clear();
        mem::swap(&mut image.old_prints, &mut image.new_prints);

        map.render(image.color_buffer.clone());

        image.map = Some(map);

        // TODO: Motion blur support.
        if let Some(RenderExt::PostCopy((dst, _, _, region))) = post_copy {
            let (src_ptr, _) = Arc::get_mut(&mut image.color_buffer.mapping).unwrap().as_ptr_len();
            let src_bytes_per_row = image.color_buffer.stride * 4;
            let dst_image = self.images.get_mut(dst).expect("invalid image");
            let (dst_ptr, dst_len) =
                Arc::get_mut(&mut dst_image.color_buffer.mapping).unwrap().as_ptr_len();
            let dst_bytes_per_row = dst_image.color_buffer.stride * 4;
            Self::copy_region(
                src_ptr,
                width,
                height,
                src_bytes_per_row,
                dst_ptr,
                dst_len as usize,
                dst_bytes_per_row,
                region,
            );
        }
    }
}