渲染与性能

if let surface = self.addSurface(width: surfaceWidth, height: surfaceHeight,
                                 pixelFormat: renderSpec.pixelFormat) {
    if let allocation = surface.allocateIfPossible(
        renderingParameters: renderingParameters
    ) {
        layer.surfaceAllocation = allocation
        layer.contentsRect = allocation.effectivePhase.contentsRect
        updatedSurfaceId = allocation.surfaceId
    }
}
// ...
if previousSurfaceId != updatedSurfaceId {
    if let updatedSurfaceId {
        layer.contents = self.surfaces[updatedSurfaceId]?.ioSurface
    } else {
        layer.contents = nil
    }
}

} else if renderingParameters.allocationWidth >= 1024 ||
          renderingParameters.allocationHeight >= 1024 {
    let surfaceWidth = max(1024, alignUp(
        renderingParameters.allocationWidth * 2, alignment: 64
    ))
    let surfaceHeight = max(512, alignUp(
        renderingParameters.allocationHeight, alignment: 64
    ))
    if let surface = self.addSurface(width: surfaceWidth,
                                     height: surfaceHeight,
                                     pixelFormat: renderSpec.pixelFormat) {
        if let allocation = surface.allocateIfPossible(
            renderingParameters: renderingParameters
        ) {
            layer.surfaceAllocation = allocation
            layer.contentsRect = allocation.effectivePhase.contentsRect
        }
    }
}
// EDR is normally used by one expanded subject. Avoid a full 32 MB atlas.

let isFirst = self.updatedSubjectIds.isEmpty

if !self.updatedSubjectIds.contains(internalId) {
    self.updatedSubjectIds.append(internalId)
    self.updatedSubjects.append(SubjectReference(subject: subject))
}

if isFirst {
    self.setNeedsDisplay()
}

self.textures = (0 ..< 3).compactMap { _ -> Texture? in
    let descriptor = MTLTextureDescriptor.texture2DDescriptor(
        pixelFormat: spec.pixelFormat.metalFormat,
        width: spec.width, height: spec.height, mipmapped: false
    )
    descriptor.storageMode = .private
    descriptor.usage = [.shaderRead, .shaderWrite]
    return device.makeTexture(descriptor: descriptor).map(Texture.init)
}
// ...
for texture in self.textures {
    if !texture.isInUse {
        texture.isInUse = true
        context.freeResourcesOnCompletion.append(texture)
        return TexturePlaceholder(placeholer: placeholder, spec: self.spec)
    }
}

static func serialize(_ archive: MTLBinaryArchive, to url: URL) throws {
    guard let failedMoveErrors = FailedMoveErrors.shared else {
        throw UnprotectedError()
    }
    failedMoveErrors.beginKeeping(forTarget: url)
    defer { failedMoveErrors.endKeeping(forTarget: url) }
    try archive.serialize(to: url)
}
// ...
let selector = NSSelectorFromString(
    "replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error:"
)
guard let method = class_getInstanceMethod(FileManager.self, selector) else { return nil }
let original = unsafeBitCast(method_getImplementation(method), to: ReplaceItemImplementation.self)
method_setImplementation(method, imp_implementationWithBlock(
    unsafeBitCast(replacement, to: AnyObject.self)
))

self.isSaveScheduled = true
self.saveQueue.asyncAfter(deadline: .now() + 1.0) { [weak self] in
    self?.save()
}
// ...
let saveMarkerUrl = MetalPipelineCache.saveMarkerUrl(archiveUrl: url)
guard FileManager.default.createFile(atPath: saveMarkerUrl.path, contents: nil) else { return }
defer { let _ = try? FileManager.default.removeItem(at: saveMarkerUrl) }

let temporaryUrl = url.deletingLastPathComponent().appendingPathComponent(
    UUID().uuidString + ".tmp"
)
try MetalBinaryArchiveSerialization.serialize(archive, to: temporaryUrl)
if rename(temporaryUrl.path, url.path) != 0 {
    let _ = try? FileManager.default.removeItem(at: temporaryUrl)
}

private(set) var isPlaying: Bool = false {
    didSet {
        if self.isPlaying != oldValue {
            if self.isPlaying {
                if self.displayTimer == nil {
                    let frameInterval = Double(self.frameSkip) / 60.0
                    let displayTimer = Foundation.Timer(
                        timeInterval: frameInterval, target: TimerTarget { [weak self] in
                            self?.animationTick(frameInterval: frameInterval)
                        }, selector: #selector(TimerTarget.timerEvent),
                        userInfo: nil, repeats: true
                    )
                    self.displayTimer = displayTimer
                    RunLoop.main.add(displayTimer, forMode: .common)
                }
            } else if let displayTimer = self.displayTimer {
                self.displayTimer = nil
                displayTimer.invalidate()
            }
        }
    }
}

let itemKey = ItemKey(id: itemId, width: Int(size.width),
                      height: Int(size.height), uniqueId: uniqueId)
let itemContext: ItemAnimationContext
if let current = self.itemContexts[itemKey] {
    itemContext = current
} else {
    let queueAffinity = self.nextQueueAffinity
    self.nextQueueAffinity += 1
    itemContext = ItemAnimationContext(cache: cache,
        queueAffinity: queueAffinity, itemId: itemId, size: size,
        useYuvA: useYuvA, fetch: fetch, stateUpdated: { [weak self] in
            self?.updateIsPlaying()
        })
    self.itemContexts[itemKey] = itemContext
}
let index = itemContext.targets.add(Weak(target))
itemContext.updateAddedTarget(target: target)

let tasks0 = tasks.filter { $0.queueAffinity % 2 == 0 }
let tasks1 = tasks.filter { $0.queueAffinity % 2 == 1 }
let allTasks = [tasks0, tasks1]
let taskCompletions = Atomic<[Int: [() -> Void]]>(value: [:])
let queues: [Queue] = [ItemAnimationContext.queue0, ItemAnimationContext.queue1]

for i in 0 ..< 2 {
    let partTasks = allTasks[i]
    queues[i].async {
        var completions: [() -> Void] = []
        for task in partTasks { completions.append(task.task()) }
        let _ = taskCompletions.modify { current in
            var current = current
            current[i] = completions
            return current
        }
    }
}

let isKeyframe: Bool
if !isFirstFrame && !insertKeyframe {
    isKeyframe = false
    // previous + delta = current
    // delta = current - previous
    yuvaSurface.toCoefficients(target: differenceCoefficients)
    differenceCoefficients.subtract(other: previousCoefficients)
    dctCoefficients = differenceCoefficients
} else {
    isKeyframe = true
    yuvaSurface.toCoefficients(target: dctCoefficients)
}
// ...
try compressedWriter.writeUInt32(isKeyframe ? 1 : 0)
for i in 0 ..< 4 {
    let dctPlane: DctCoefficientPlane
    // yPlane, uPlane, vPlane, aPlane
    try compressedWriter.writeUInt32(UInt32(dctPlane.data.count))
    try dctPlane.data.withUnsafeBytes { bytes in
        try compressedWriter.write(bytes: bytes.baseAddress!.assumingMemoryBound(to: UInt8.self),
                                   count: bytes.count)
    }
}

let key = ItemKey(id: sourceId, width: Int(size.width), height: Int(size.height))
let itemContext: ItemContext
var beginFetch = false
if let current = self.itemContexts[key] {
    itemContext = current
} else {
    itemContext = ItemContext()
    self.itemContexts[key] = itemContext
    beginFetch = true
}
let index = itemContext.subscribers.add(updateResult)

if beginFetch {
    let fetchQueueIndex = self.nextFetchQueueIndex
    self.nextFetchQueueIndex += 1
    guard let writer = AnimationCacheItemWriterImpl(
        queue: self.fetchQueues[fetchQueueIndex % self.fetchQueues.count],
        allocateTempFile: self.allocateTempFile, completion: { /* ... */ }
    ) else { return EmptyDisposable }

for _ in 0 ..< higherResolutionItem.numFrames {
    try writer.addYUV(with: { yuva in
        guard let frame = higherResolutionItem.advance(
            advance: .frames(1),
            requestedFormat: .yuva(rowAlignment: yuva.yPlane.rowAlignment)
        ) else { return nil }
        switch frame.frame.format {
        case let .yuva(y, u, v, a):
            yuva.yPlane.copyScaled(fromPlane: y)
            yuva.uPlane.copyScaled(fromPlane: u)
            yuva.vPlane.copyScaled(fromPlane: v)
            yuva.aPlane.copyScaled(fromPlane: a)
        default: return nil
        }
        return frame.frame.duration
    }, proposedWidth: width, proposedHeight: height, insertKeyframe: true)
}

self.bytesPerRow = bytesPerRow ??
    DeviceGraphicsContextSettings.shared.bytesPerRow(forWidth: Int(scaledSize.width))
self.length = self.bytesPerRow * Int(scaledSize.height)
guard let imageBuffer = ASCGImageBuffer(length: UInt(self.length)) else { return nil }
self.imageBuffer = imageBuffer

guard let context = CGContext(
    data: self.imageBuffer.mutableBytes,
    width: Int(self.scaledSize.width), height: Int(self.scaledSize.height),
    bitsPerComponent: DeviceGraphicsContextSettings.shared.bitsPerComponent,
    bytesPerRow: self.bytesPerRow,
    space: colorSpace ?? DeviceGraphicsContextSettings.shared.colorSpace,
    bitmapInfo: self.bitmapInfo.rawValue,
    releaseCallback: nil, releaseInfo: nil
) else { return nil }
self.context = context
// ...
let dataProvider = self.imageBuffer.createDataProviderAndInvalidate()

let ioSurfaceProperties = NSMutableDictionary()
let options = NSMutableDictionary()
options.setObject(ioSurfaceProperties,
                  forKey: kCVPixelBufferIOSurfacePropertiesKey as NSString)

var pixelBuffer: CVPixelBuffer?
CVPixelBufferCreateWithBytes(nil, Int(self.scaledSize.width),
    Int(self.scaledSize.height), kCVPixelFormatType_32BGRA,
    self.bytes, self.bytesPerRow, { pointer, _ in
        if let pointer = pointer {
            Unmanaged<ASCGImageBuffer>.fromOpaque(pointer).release()
        }
    }, Unmanaged.passRetained(self.imageBuffer).toOpaque(),
    options as CFDictionary, &pixelBuffer)

self.hasGeneratedImage = true
return pixelBuffer

if !self.targetContexts.isEmpty {
    if self.displayLink == nil {
        self.displayLink = SharedDisplayLinkDriver.shared.add { [weak self] _ in
            self?.updateRendering()
        }
    }
} else {
    self.displayLink = nil
}
// ...
if targetState.sampleBuffers.count < 2 {
    renderIds[id] = 2 - targetState.sampleBuffers.count
}
// ...
BatchVideoRenderingContext.sharedQueue.async {
    for (id, (count, readingContext)) in readingContexts {
        for _ in 0 ..< count {
            if let sampleBuffer = readingContext.unsafeGet()?.advance() {
                sampleBuffers[id]?.append(sampleBuffer)
            }
        }
    }
}

let sampleBuffer = self.sampleBuffers[0]
let sampleBufferPts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer).seconds
let sampleBufferDuration = CMSampleBufferGetDuration(sampleBuffer).seconds
if let lastRenderedFrame = self.lastRenderedFrame {
    let elapsedTime = timestamp - lastRenderedFrame.timestamp
    let ptsDifference = sampleBufferPts - lastRenderedFrame.pts
    if ptsDifference < 0.0 {
        if elapsedTime >= lastRenderedFrame.duration {
            self.lastRenderedFrame = (timestamp, sampleBufferPts, sampleBufferDuration)
            self.sampleBuffers.removeFirst()
            return sampleBuffer
        }
    } else if elapsedTime >= ptsDifference {
        self.lastRenderedFrame = (timestamp, sampleBufferPts, sampleBufferDuration)
        self.sampleBuffers.removeFirst()
        return sampleBuffer
    }
}

let reader = FFMpegFileReader(
    source: .file(self.dataPath),
    useHardwareAcceleration: false,
    // These render into ~93pt tiles, where deblocking is not visible.
    skipLoopFilter: true,
    selectedStream: .mediaType(.video),
    seek: nil, maxReadablePts: nil
)
// ...
case .endOfStream:
    if !self.readerDidProduceFrame {
        self.isFailed = true
        break outer
    }
    self.reader = nil
case .waitingForMoreData:
    self.isFailed = true
    break outer

let decompressedData = TGGUnzipData(data, 2 * 1024 * 1024) ?? data
guard let animation = makeLottieInstance(
    data: decompressedData, fitzModifier: .none,
    colorReplacements: nil, cacheKey: "", settings: lottieSettings
) else {
    writer.finish()
    return
}

let frameSkip: Int = 2
let frameDuration = Double(frameSkip) / Double(animation.frameRate)
for i in stride(from: 0, through: animation.frameCount - 1, by: frameSkip) {
    if writer.isCancelled { break }
    writer.add(with: { surface in
        animation.renderFrame(with: i, into: surface.argb,
            width: Int32(surface.width), height: Int32(surface.height),
            bytesPerRow: Int32(surface.bytesPerRow))
        return frameDuration
    }, proposedWidth: width, proposedHeight: height,
       insertKeyframe: i == 0 || keyframeOnly)
}

var anyAdvanced = false
for (slot, context) in self.spriteContexts {
    guard context.isPlaying else { continue }
    context.remainingDuration -= advanceTimestamp
    if context.remainingDuration <= 0.0 {
        surface.advanceSprite(atSlot: Int32(slot))
        context.currentFrameIndex += 1
        if context.currentFrameIndex >= context.metadata.frameCount {
            context.currentFrameIndex = 0
        }
        context.remainingDuration = context.metadata.frameDurations[context.currentFrameIndex]
        anyAdvanced = true
    }
}
if !anyAdvanced { return }
self.accumulatedNalData = Data()
try? surface.emitFrameIfNeeded { [weak self] data in
    self?.accumulatedNalData.append(data)
}
guard let frames = try? decoder.decodeStream(self.accumulatedNalData) else { return }

let threadgroupSize = MTLSize(width: 32, height: 1, depth: 1)
let threadgroupCount = MTLSize(
    width: (particleRowCount * particleColumnCount + threadgroupSize.width - 1)
        / threadgroupSize.width,
    height: 1, depth: 1
)
computeEncoder.setBuffer(particleBuffer.buffer, offset: 0, index: 0)
if !item.particleBufferIsInitialized {
    item.particleBufferIsInitialized = true
    computeEncoder.setComputePipelineState(state.computePipelineStateInitializeParticle)
    computeEncoder.dispatchThreadgroups(threadgroupCount,
                                        threadsPerThreadgroup: threadgroupSize)
}
computeEncoder.setComputePipelineState(state.computePipelineStateUpdateParticle)
computeEncoder.dispatchThreadgroups(threadgroupCount,
                                    threadsPerThreadgroup: threadgroupSize)
// ...
encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 6,
                       instanceCount: particleCount)

int sourceBytesPerRow = (3 * width + 31) & ~0x1F;
int targetBytesPerRow = (4 * width + 31) & ~0x1F;
unsigned char *buffer = (uint8_t *)malloc(sourceBytesPerRow * height);

tjDecompress2(_jpegDecompressor, _compressedImage, jpegSize,
              buffer, width, sourceBytesPerRow, height, TJPF_RGB,
              TJFLAG_FASTDCT | TJFLAG_FASTUPSAMPLE);

vImage_Buffer source = { .width = width, .height = height,
                         .rowBytes = sourceBytesPerRow, .data = buffer };
vImage_Buffer target = { .width = width, .height = height,
                         .rowBytes = targetBytesPerRow, .data = targetBuffer };
vImageConvert_RGB888toARGB8888(&source, nil, 0xff, &target,
                                false, kvImageDoNotTile);
const uint8_t permuteMap[4] = {3, 2, 1, 0};
vImagePermuteChannels_ARGB8888(&target, &permuteTarget, permuteMap,
                               kvImageDoNotTile);

private final class SampleBufferLayerImplNullAction: NSObject, CAAction {
    @objc func run(forKey event: String, object anObject: Any,
                   arguments dict: [AnyHashable : Any]?) {}
}

private final class SampleBufferLayerImpl: AVSampleBufferDisplayLayer {
    override func action(forKey event: String) -> CAAction? {
        return SampleBufferLayerImplNullAction()
    }
}

private let pool = Atomic<[AVSampleBufferDisplayLayer]>(value: [])
// ...
Queue.mainQueue().async {
    layer.flushAndRemoveImage()
    layer.setAffineTransform(CGAffineTransform.identity)
    let _ = pool.modify { list in
        var list = list
        list.append(layer)
        return list
    }
}