Supporting HDR images in your app

At a glance

Project structure

Source bundle/
├── HDRDemo23/
│   ├── HDRDemo23App.swift
│   ├── RenderView.swift
│   ├── AdjustView.swift
│   ├── ImageView.swift
│   ├── MainView.swift
│   ├── Renderer.swift
│   ├── Adjustment.swift
│   ├── Asset.swift
│   ├── EditedAsset.swift
│   └── FilmStrip.swift
├── Configuration/
│   └── SampleCode.xcconfig
└── HDRDemo23.xcodeproj/
    └── .xcodesamplecode.plist

Structure observations

• The app entry creates MainView; the image pipeline is not owned by an application delegate.
• EditedAsset centralizes observable adjustment state and triggers rendering without overwriting the source Asset.
• Conditional compilation is limited to the pixel-buffer platform adapter; editing and renderer types are shared.

Overall architecture

flowchart LR
    APP["HDRDemo23App"] --> MAIN["MainView import, selection, export"]
    MAIN --> SOURCE["Asset original image"]
    MAIN --> EDIT["EditedAsset observable edit session"]
    EDIT --> ADJ["Adjustment filters"]
    ADJ --> RENDERER["Renderer and CIContext"]
    RENDERER --> BUFFER["HDR CVPixelBuffer"]
    BUFFER --> VIEW["RenderView / PixelBufferView"]
    EDIT --> EXPORT["Photos or FileDocument export"]

Reference code

HDRDemo23/EditedAsset.swift:92 — adjustment-to-render pipeline

    func applyAdjustments(_ adjustments: [Adjustment], showOriginal: Bool) async {
        var image = inputImage
        if !showOriginal {
            for adjustment in adjustments {
                image = adjustment.apply(to: image)
            }
        }
        if let image,
           let pixelBuffer = await renderer.render(image, destinationColorspace: inputImage?.colorSpace) {
            setPixelBuffer(pixelBuffer)
        }
    }

Interpretation

The view coordinates a user session, but the edit model owns the editable image state and render trigger. The renderer owns Core Image execution and HDR buffer construction. Presentation observes only the resulting buffer, keeping file/Photos workflows outside the drawing adapter.

Ownership and state

classDiagram
    MainView *-- Renderer : creates
    MainView *-- AssetArray : State
    MainView *-- EditedAsset : State edit session
    EditedAsset o-- Renderer : injected
    EditedAsset o-- Asset : original
    EditedAsset *-- AdjustmentArray : editable state
    EditedAsset *-- CVPixelBuffer : latest render
    RenderView --> EditedAsset : observes

Ownership evidence

HDRDemo23/MainView.swift:16 — feature-root state and renderer

    var renderer = Renderer()

    @State var selectedItems: [PhotosPickerItem] = []
    @State var assets: [Asset] = []
    @State var selectedAsset: Asset?
    @State var editedAsset: EditedAsset?

    @State var isEditing: Bool = false

Composition denotes source-visible construction and retained value state. Aggregation denotes a stored or injected collaborator whose exclusive lifetime the source does not prove.

Class and protocol design

HDRDemo23/EditedAsset.swift:17 — observable main-actor edit model

@MainActor
@Observable
class EditedAsset: FileDocument {
    nonisolated
    static var readableContentTypes: [UTType] { [.image] }

    let renderer: Renderer
    let asset: Asset
    var pixelBuffer: CVPixelBuffer? = nil
}

FileDocument and the representable protocols are framework integration contracts. The sample defines no local service protocol; Renderer is injected concretely into each EditedAsset.

Access control

Reference code

HDRDemo23/EditedAsset.swift:21 — concurrency boundary on document requirements

    nonisolated
    static var readableContentTypes: [UTType] { [.image] }

    nonisolated
    static var writableContentTypes: [UTType] { [.heic, .png] }

    let renderer: Renderer
    let asset: Asset

nonisolated changes actor isolation, not Swift visibility. Declarations without an access modifier remain internal; the only concrete private boundary highlighted here is the asset’s thumbnail loader.

Logic ownership and placement

Design patterns

Naming conventions

• Domain nouns (Asset, EditedAsset, Adjustment, Renderer) describe data ownership rather than screen position.
• View types use a View suffix; platform bridge PixelBufferView names the value it presents.
• Commands use workflow verbs (toggleEdit, saveEdit, applyAdjustments, render, export).
• Concurrency annotations are placed on the state-owning type or method, not encoded in names.

Architecture takeaways

• Keep import/export coordination in the feature view and image mutation in an observable edit-session model.
• Give color-space, pixel-buffer, and encoding details to one renderer service.
• Treat @MainActor and nonisolated as concurrency design, not visibility declarations.

Source map

• Official Apple documentation