渲染与应用层

if !self.data.hasAlreadyFrame(Int(current.1)) {
    current.0.withUnsafeBytes { pointer in
        let ui64Address = pointer.baseAddress!.assumingMemoryBound(to: UInt64.self)
        var length:Int = self.bufferSize
        if let previous = previous, enableDifference {
            let uint64Bs = self.bufferSize / 8
            previous.withUnsafeBytes { pointer in
                // ... `previous` 复制到 `dstDelta` 并重绑定为 `ui64Dst`。
                var i: Int = 0
                while i < uint64Bs {
                    ui64Dst[i] = ui64Dst[i] ^ ui64Address[i]
                    i &+= 1
                }
                length = compression_encode_buffer(dst, self.bufferSize, ui8, self.bufferSize, nil, COMPRESSION_LZFSE)
            }
        } else {
            length = compression_encode_buffer(dst, self.bufferSize, address, self.bufferSize, nil, COMPRESSION_LZFSE)
        }
        _ = self.data.writeFrame(frame: Int(current.1), data: Data(bytes: dst, count: length))
    }
}
// ... 解码后按 UInt64 再次 XOR `previousBytes[i] ^ address[i]`。

private static var cache: [Key : MultiTargetAnimationContext] = [:]

static func create(_ animation: LottieAnimation, key: Key,
                   displayFrame: @escaping(CGImage?)->Void,
                   release: @escaping()->Void,
                   updateState: @escaping(LottiePlayerState)->Void) -> Int {
    assertOnMainThread()
    let handlers = MultiTargetAnimationContext.Handlers(
        displayFrame: displayFrame, release: release, updateState: updateState)
    if let context = cache[key] {
        return context.add(handlers)
    }
    var token: Int = 0
    let context = MultiTargetAnimationContext(animation, handlers: handlers, token: &token)
    cache[key] = context
    return token
}

static func remove(_ token: Int, for key: Key) {
    if let context = self.cache[key], context.remove(token) {
        self.cache.removeValue(forKey: key)
    }
}

private final class Loop {
    var list:[RenderLoopItem] = []
    init(_ runLoop: LottieRunLoop, commandQueue: MTLCommandQueue) {
        self.commandQueue = commandQueue
        self.timer = SwiftSignalKit.Timer(
            timeout: 1 / TimeInterval(runLoop.fps), repeat: true,
            completion: { [weak self] in self?.renderItems() }, queue: lottieStateQueue)
        self.timer?.start()
    }
    private func renderItems() {
        let commandBuffer = self.commandQueue.makeCommandBuffer()
        if let commandBuffer = commandBuffer {
            var drawables: [MTLDrawable] = []
            while !self.list.isEmpty {
                let item = self.list.removeLast()
                if let drawable = item.render(commandBuffer) { drawables.append(drawable) }
            }
            if drawables.isEmpty { return }
            commandBuffer.addScheduledHandler { _ in
                for drawable in drawables { drawable.present() }
            }
            commandBuffer.commit()
        }
    }
}

if let readerValue = reader.with({ $0 }), let outputValue = output.with({ $0 }) {
    let affineTransform = track.with { $0?.preferredTransform.inverted() }
    if let affineTransform = affineTransform {
        layer.setAffineTransform(affineTransform)
    }
    while layer.isReadyForMoreMediaData {
        if !stopRequesting.with({ $0 }) {
            if readerValue.status == .reading,
               let sampleBuffer = outputValue.copyNextSampleBuffer() {
                layer.enqueue(sampleBuffer)
                continue
            }
            _ = stopRequesting.modify { _ in _data.with { $0 } == nil }
            break
        }
    }
    if readerValue.status == .completed || readerValue.status == .cancelled {
        if reset.swap(false) {
            let result = restartReading(/* ... */ layer: layer, _timebase: timebase)
            if result { layer.flush() }
        }
    }
}
// ... `output.alwaysCopiesSampleData = false`。
// ... `CMTimebaseCreateWithSourceClock(... CMClockGetHostTimeClock(), ...)`。

let pool: PixelBufferPool?
if let current = pixelBufferPoolState.pool,
   current.width == width, current.height == height {
    pool = current
} else {
    pool = PixelBufferPool(width: width, height: height)
    pixelBufferPoolState.pool = pool
}
guard let pool else { return }

let auxAttributes: [String: Any] = [
    kCVPixelBufferPoolAllocationThresholdKey as String: 5 as NSNumber
]
var pixelBuffer: CVPixelBuffer?
let result = CVPixelBufferPoolCreatePixelBufferWithAuxAttributes(
    kCFAllocatorDefault, pool.pool, auxAttributes as CFDictionary, &pixelBuffer)
if result == kCVReturnWouldExceedAllocationThreshold {
    print("kCVReturnWouldExceedAllocationThreshold, dropping frame")
    return
}
guard let pixelBuffer else { return }
if !copyI420BufferToNV12Buffer(buffer: i420Buffer, pixelBuffer: pixelBuffer) { return }

switch videoTextures.textureLayout {
case let .bgra(texture):
    computeEncoder.setComputePipelineState(blurState.computePipelineStateBGRAToRGBA)
    computeEncoder.setTexture(texture.bgra, index: 0)
    computeEncoder.setTexture(rgbaTexture, index: 1)
case let .biPlanar(biPlanar):
    computeEncoder.setComputePipelineState(blurState.computePipelineStateYUVBiPlanarToRGBA)
    computeEncoder.setTexture(biPlanar.y, index: 0)
    computeEncoder.setTexture(biPlanar.uv, index: 1)
    computeEncoder.setTexture(rgbaTexture, index: 2)
case let .triPlanar(triPlanar):
    computeEncoder.setComputePipelineState(blurState.computePipelineStateYUVTriPlanarToRGBA)
    computeEncoder.setTexture(triPlanar.y, index: 0)
    computeEncoder.setTexture(triPlanar.u, index: 1)
    computeEncoder.setTexture(triPlanar.u, index: 2)
    computeEncoder.setTexture(rgbaTexture, index: 3)
}
blurState.downscaleKernel.encode(
    commandBuffer: commandBuffer, sourceTexture: rgbaTexture, destinationTexture: downscaledTexture)
computeEncoder.setComputePipelineState(blurState.computePipelineStateHorizontal)
computeEncoder.setTexture(downscaledTexture, index: 0)
computeEncoder.setTexture(blurredHorizontalTexture, index: 1)
computeEncoder.setComputePipelineState(blurState.computePipelineStateVertical)
computeEncoder.setTexture(blurredHorizontalTexture, index: 0)
computeEncoder.setTexture(blurredVerticalTexture, index: 1)

public func ApplyDustAnimation(for currentView: NSView) {
    guard let window = currentView.window, isChipM2OrHigher() else {
        return
    }
    #if arch(arm64)
    window.contentView?.layer?.addSublayer(MetalEngine.shared.rootLayer)
    let metalLayer = DustLayer()
    metalLayer.isInHierarchy = true
    metalLayer.frame = window.contentView!.bounds
    let view = View(frame: metalLayer.frame.size.bounds)
    view.isEventLess = true
    view.layer?.addSublayer(metalLayer)
    window.contentView?.addSubview(view)
    metalLayer.becameEmpty = { [weak view] in
        view?.removeFromSuperview()
    }
    #endif
}

for subview in views {
    view.metalLayer.addItem(
        frame: CGRect(origin: subview.convert(.zero, to: view), size: subview.frame.size),
        image: subview.snapshot)
}

private func updateNeedsAnimation() {
    if !self.items.isEmpty && self.isInHierarchy {
        if self.updateLink == nil {
            self.updateLink = SharedDisplayLinkDriver.shared.add(
                framesPerSecond: .max, { [weak self] deltaTime in
                    guard let self else { return }
                    self.updateItems(deltaTime: deltaTime)
                    self.setNeedsUpdate()
                })
            self.setNeedsUpdate()
        }
    } else if self.updateLink != nil {
        self.updateLink = nil
    }
}

if !item.particleBufferIsInitialized {
    item.particleBufferIsInitialized = true
    computeEncoder.setComputePipelineState(state.computePipelineStateInitializeParticle)
    computeEncoder.dispatchThreadgroups(threadgroupCount, threadsPerThreadgroup: threadgroupSize)
}
computeEncoder.setComputePipelineState(state.computePipelineStateUpdateParticle)
encoder.setVertexBuffer(particleBuffer.buffer, offset: 0, index: 3)
encoder.setFragmentTexture(item.texture, index: 0)
encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 6, instanceCount: particleCount)

const int radius = 7;
const int r1 = radius + 1;
const int div = radius * 2 + 1;
if (radius > 15 || div >= w || div >= h) { return; }

uint64_t *rgb = malloc(imageStride * imageHeight * sizeof(uint64_t));
uint64_t cur = get_colors(&pix[yw]);
uint64_t rgballsum = -radius * cur;
uint64_t rgbsum = cur * ((r1 * (r1 + 1)) >> 1);

#define update(start, middle, end)                         \
rgb[y * w + x] = (rgbsum >> 6) & 0x00FF00FF00FF00FF;      \
rgballsum += get_colors(&pix[yw + (start) * 4]) -          \
    2 * get_colors(&pix[yw + (middle) * 4]) +              \
    get_colors(&pix[yw + (end) * 4]);                       \
rgbsum += rgballsum; x++;

while (x < r1) { update(0, x, x + r1); }
while (x < we) { update(x - r1, x, x + r1); }
while (x < w) { update(x - r1, x, w - 1); }

let imageSize = size.fitted(CGSize(width: 16, height: 16)).integralFloor
let positions = gatherPositions(
    shiftArray(array: AnimatedGradientBackgroundView.basePositions, offset: self.phase % 8))

let fps: Double = extendAnimation ? 60 : 30
let maxFrame = Int(duration * fps)
for frameIndex in 0 ..< maxFrame {
    let t = curve.solve(at: CGFloat(frameIndex) / CGFloat(maxFrame - 1))
    let globalStep = Int(t * CGFloat(maxFrame))
    let stepIndex = min(stepCount - 1, globalStep / framesPerAnyStep)
    let stepT = CGFloat(stepFrameIndex) / CGFloat(stepFrames - 1)
    var morphedPositions: [CGPoint] = []
    for i in 0 ..< steps[0].count {
        morphedPositions.append(interpolatePoints(
            steps[stepIndex][i], steps[stepIndex + 1][i], at: stepT))
    }
    images.append(generateGradient(size: imageSize, colors: self.colors, positions: morphedPositions))
}
self.contentView.image = images.last
let animation = CAKeyframeAnimation(keyPath: "contents")
animation.values = images.map { $0 }
animation.duration = duration
self.contentView.layer!.add(animation, forKey: "contents")

private func decodeStickerThumbnailData(_ data: Data) -> String {
    var string = "M"
    data.forEach { byte in
        if byte >= 128 + 64 {
            string.append(decodingMap[Int(byte) - 128 - 64])
        } else {
            // ... 写入逗号或负号。
            string.append("\(byte & 63)")
        }
    }
    string.append("z")
    return string
}
let signal: Signal<CGImage?, NoError> = Signal { subscriber in
    let image = generateImage(size, rotatedContext: { size, context in
        var path = decodeStickerThumbnailData(data)
        if !path.hasPrefix("z") { path = "\(path)z" }
        let segments = PathDataReader(input: path).read()
        let scale = max(size.width, size.height) / max(imageSize.width, imageSize.height)
        context.scaleBy(x: scale, y: scale)
        renderPath(segments, context: context)
    })
    subscriber.putNext(image)
    subscriber.putCompletion()
    // ... `return EmptyDisposable` 后转入并发队列。

displayLinkAnimator = ConstantDisplayLinkAnimator(update: { [weak self] in
    guard let strongSelf = self, let window = self?.window, window.isVisible else { return }
    strongSelf.presentationAudioLevel =
        strongSelf.presentationAudioLevel * 0.9 + strongSelf.audioLevel * 0.1
    strongSelf.smallBlob.level = strongSelf.presentationAudioLevel
    strongSelf.mediumBlob.level = strongSelf.presentationAudioLevel
    strongSelf.bigBlob.level = strongSelf.presentationAudioLevel
})

public func updateLevel(_ level: CGFloat) {
    let normalizedLevel = min(1, max(level / maxLevel, 0))
    smallBlob.updateSpeedLevel(to: normalizedLevel)
    mediumBlob.updateSpeedLevel(to: normalizedLevel)
    bigBlob.updateSpeedLevel(to: normalizedLevel)
    audioLevel = normalizedLevel
}

let currSmoothOut = curr.smoothOut()
let nextSmoothIn = next.smoothIn()
resultPath.addCurve(to: next.point, control1: currSmoothOut, control2: nextSmoothIn)
resultPath.closeSubpath()

if resourceData.complete,
   let data = try? Data(contentsOf: URL(fileURLWithPath: resourceData.path),
                        options: [.mappedIfSafe]) {
    let playPolicy: LottiePlayPolicy = file.isEmojiAnimatedSticker ? .once : .loop
    let maximumFps: Int = size.width < 200 && !file.isEmojiAnimatedSticker ? 30 : 60
    let fitzModifier = file.animatedEmojiFitzModifier
    self?.sticker = LottieAnimation(
        compressed: data,
        key: LottieAnimationEntryKey(key: .media(file.id), size: size, fitzModifier: fitzModifier),
        cachePurpose: size.width < 200 ? .temporaryLZ4(.thumb) :
            self?.parent != nil ? .temporaryLZ4(.chat) : .none,
        playPolicy: playPolicy, maximumFps: maximumFps)
}

self.thumbView.setSignal(signal: cachedMedia(media: file, arguments: arguments,
                                             scale: backingScaleFactor), clearInstantly: updated)
if !self.thumbView.isFullyLoaded { /* 继续请求贴纸缩略图 */ }
stateDisposable.set((self.playerView.state |> deliverOnMainQueue).start(next: { state in
    self.playerView.isHidden = state != .playing
    self.thumbView.isHidden = state == .playing
}))

private var contextToken: (Int, MultiTargetContextCache.Key)?
private func set(_ animation: LottieAnimation?, force: Bool = false) {
    self.animation = animation
    if let animation = animation, let isPlayable = self.isPlayable, isPlayable, !stopped {
        weak var layer: InlineStickerItemLayer? = self
        let key = MultiTargetContextCache.Key(key: animation.key, unique: unique)
        delayDisposable.set(delaySignal(
            MultiTargetContextCache.exists(key) || force || noDelayBeforeplay ? 0 : 0.1
        ).start(completed: { [weak self] in
            self?.contextToken = (MultiTargetContextCache.create(animation, key: key,
                displayFrame: { image in
                    layer?.contents = image
                    if layer?.isPreviousPreview == true {
                        layer?.animateContents()
                        layer?.isPreviousPreview = false
                    }
                    if self?.superview?.window == nil {
                        DispatchQueue.main.async { self?.set(nil, force: true) }
                    }
                }, release: {}, updateState: { [weak self] state in
                    self?.updateState(state)
                }), key)
        }))
    }
}

@objc func updateAnimatableContent() -> Void {
    if controlContent {
        var isKeyWindow = false
        if let window = window {
            if !window.canBecomeKey {
                isKeyWindow = true
            } else {
                isKeyWindow = window.isKeyWindow
            }
        }
        animateLayer.isPlayable = isKeyWindow && isPlayable && self.visibleRect != .zero
    }
}
center.addObserver(self, selector: #selector(updateAnimatableContent),
                   name: NSWindow.didBecomeKeyNotification, object: window)
center.addObserver(self, selector: #selector(updateAnimatableContent),
                   name: NSView.boundsDidChangeNotification,
                   object: self.enclosingScrollView?.contentView)
center.addObserver(self, selector: #selector(updateAnimatableContent),
                   name: NSView.frameDidChangeNotification,
                   object: self.enclosingScrollView?.documentView)

fileprivate class ModernPictureInPictureVideoWindow: NSPanel {
    init(_ control: PictureInPictureControl, item: MGalleryItem,
         viewer: GalleryViewer, origin: NSPoint, type: GalleryAppearType) {
        let minSize = control.view.frame.size.aspectFilled(NSMakeSize(120, 120))
        let size = item.notFittedSize.aspectFilled(NSMakeSize(250, 250)).aspectFilled(minSize)
        let newRect = NSMakeRect(origin.x, origin.y, size.width, size.height)
        __window = Window(contentRect: newRect, styleMask: [.resizable],
                          backing: .buffered, defer: true)
        __window.setFrame(NSMakeRect(3000, 3000, saver.rect.width, saver.rect.height), display: true)
        super.init(contentRect: newRect, styleMask: [.resizable, .nonactivatingPanel],
                   backing: .buffered, defer: true)
        self.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
        self.contentView = PictureInpictureView(frame: bounds, window: __window)
        view.forceMouseDownCanMoveWindow = true
        self.contentView?.layer?.cornerRadius = 4
        control.view.frame = NSMakeRect(0, 0, newRect.width, newRect.height)
        contentView?.addSubview(control.view)
    }
}
// ... 将越界窗口框吸附回可见区域。

float frameDuration = 0.1f;
NSDictionary *gifProperties = frameProperties[(NSString*)kCGImagePropertyGIFDictionary];
NSNumber *delayTimeUnclampedProp = gifProperties[(NSString*)kCGImagePropertyGIFUnclampedDelayTime];
if (delayTimeUnclampedProp) {
    frameDuration = [delayTimeUnclampedProp floatValue];
} else {
    NSNumber *delayTimeProp = gifProperties[(NSString*)kCGImagePropertyGIFDelayTime];
    if (delayTimeProp) { frameDuration = [delayTimeProp floatValue]; }
}
if (frameDuration < 0.011f) frameDuration = 0.100f;

if (pixelBufferPool)
    status = CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pixelBufferPool, &pxBuffer);
else
    status = CVPixelBufferCreate(kCFAllocatorDefault, width, height,
        kCVPixelFormatType_32ARGB, (__bridge CFDictionaryRef)attributes, &pxBuffer);
CVPixelBufferLockBaseAddress(pxBuffer, 0);
void *pxData = CVPixelBufferGetBaseAddress(pxBuffer);
CGContextRef context = CGBitmapContextCreate(pxData, width, height, bpc,
    bytesPerRow, colorSpace, kCGImageAlphaNoneSkipFirst);
CGContextDrawImage(context, CGRectMake(0, 0, width, height), frame);
CVPixelBufferUnlockBaseAddress(pxBuffer, 0);

let s = (w: Int(size.width) * backingScale, h: Int(size.height) * backingScale)
let destBytesPerRow = DeviceGraphicsContextSettings.shared.bytesPerRow(forWidth: s.w)
let bufferSize = s.h * DeviceGraphicsContextSettings.shared.bytesPerRow(forWidth: s.w)
let memoryData = malloc(bufferSize)!
let bytes = memoryData.assumingMemoryBound(to: UInt8.self)

let imageBuffer = CMSampleBufferGetImageBuffer(frame.sampleBuffer)
CVPixelBufferLockBaseAddress(imageBuffer!, CVPixelBufferLockFlags(rawValue: 0))
let bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer!)
let width = CVPixelBufferGetWidth(imageBuffer!)
let height = CVPixelBufferGetHeight(imageBuffer!)
let srcData = CVPixelBufferGetBaseAddress(imageBuffer!)
var sourceBuffer = vImage_Buffer(data: srcData, height: vImagePixelCount(height),
    width: vImagePixelCount(width), rowBytes: bytesPerRow)
var destBuffer = vImage_Buffer(data: bytes, height: vImagePixelCount(s.h),
    width: vImagePixelCount(s.w), rowBytes: destBytesPerRow)
_ = vImageScale_ARGB8888(&sourceBuffer, &destBuffer, nil, vImage_Flags(kvImageDoNotTile))
CVPixelBufferUnlockBaseAddress(imageBuffer!, CVPixelBufferLockFlags(rawValue: 0))
return generateImagePixel(size, scale: CGFloat(backingScale), pixelGenerator: {
    _, pixelData, _ in memcpy(pixelData, bytes, bufferSize)
})