媒体、Stories 与个人页

public extension CAEmitterCell {
    static func createEmitterBehavior(type: String) -> NSObject {
        let selector = ["behaviorWith", "Type:"].joined(separator: "")
        let behaviorClass = NSClassFromString(["CA", "Emitter", "Behavior"].joined(separator: "")) as! NSObject.Type
        let behaviorWithType = behaviorClass.method(for: NSSelectorFromString(selector))!
        let castedBehaviorWithType = unsafeBitCast(
            behaviorWithType,
            to: (@convention(c) (Any?, Selector, Any?) -> NSObject).self
        )
        return castedBehaviorWithType(behaviorClass, NSSelectorFromString(selector), type)
    }
}
// GiftAuctionBidScreen.swift
let staticColorBehavior = CAEmitterCell.createEmitterBehavior(type: "colorOverLife")
staticColorBehavior.setValue(staticColors, forKey: "colors")
staticEmitter.setValue([staticColorBehavior], forKey: "emitterBehaviors")
let attractor = CAEmitterCell.createEmitterBehavior(type: "simpleAttractor")
attractor.setValue("attractor", forKey: "name")
self.staticEmitterLayer.setValue([attractor], forKey: "emitterBehaviors")

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    guard !self.ignoreScrolling else {
        return
    }
    self.headerNode.headerEdgeEffectContainer.center = CGPoint(
        x: 0.0, y: scrollView.contentOffset.y
    )
    if !self.state.isEditing {
        if self.canAddVelocity {
            self.previousVelocityM1 = self.previousVelocity
            if let value = (scrollView.value(
                forKey: (["_", "verticalVelocity"] as [String]).joined()
            ) as? NSNumber)?.doubleValue {
                self.previousVelocity = CGFloat(value)
            }
        }
        let offsetY = self.scrollNode.view.contentOffset.y
        var shouldBeExpanded: Bool?
        if offsetY <= -32.0 && scrollView.isDragging && scrollView.isTracking {
            if let peer = self.data?.peer, self.chatLocation.threadId == nil,
               peer.smallProfileImage != nil && self.state.updatingAvatar == nil {
                shouldBeExpanded = true
            }
        }

private func makeInputTextures(pixelBuffer: CVPixelBuffer)
-> (y: CVMetalTexture, cbcr: CVMetalTexture)? {
    var yTexture: CVMetalTexture?
    let yStatus = CVMetalTextureCacheCreateTextureFromImage(
        kCFAllocatorDefault, self.textureCache, pixelBuffer, nil,
        .r8Unorm, CVPixelBufferGetWidthOfPlane(pixelBuffer, 0),
        CVPixelBufferGetHeightOfPlane(pixelBuffer, 0), 0, &yTexture
    )
    var cbcrTexture: CVMetalTexture?
    let cbcrStatus = CVMetalTextureCacheCreateTextureFromImage(
        kCFAllocatorDefault, self.textureCache, pixelBuffer, nil,
        .rg8Unorm, CVPixelBufferGetWidthOfPlane(pixelBuffer, 1),
        CVPixelBufferGetHeightOfPlane(pixelBuffer, 1), 1, &cbcrTexture
    )
    guard yStatus == kCVReturnSuccess, cbcrStatus == kCVReturnSuccess,
          let yTexture, let cbcrTexture else {
        return nil
    }
    return (yTexture, cbcrTexture)
}

let effectiveAnimationTime = animationTime.isFinite
    ? max(0.0, animationTime) : 0.0
let frameIndex = Int(floor(effectiveAnimationTime * 30.0))
    % RoundVideoDecorationAnimation.frameCount
uniforms.decoration = SIMD4<Float>(
    Float(frameIndex), Float(RoundVideoDecorationAnimation.columns),
    Float(RoundVideoDecorationAnimation.rows), 0.0
)
guard let downsampleEncoder = commandBuffer.makeComputeCommandEncoder() else {
    return
}
downsampleEncoder.setComputePipelineState(decoration.downsamplePipelineState)
downsampleEncoder.setTexture(primaryY, index: 0)
downsampleEncoder.setTexture(primaryCbCr, index: 1)
downsampleEncoder.setTexture(decoration.downsampleTexture, index: 4)
Self.dispatch(encoder: downsampleEncoder,
              pipelineState: decoration.downsamplePipelineState,
              width: RoundVideoMetalDecoration.blurWidth,
              height: RoundVideoMetalDecoration.blurHeight)
downsampleEncoder.endEncoding()
decoration.blur.encode(commandBuffer: commandBuffer,
                       sourceTexture: decoration.downsampleTexture,
                       destinationTexture: decoration.blurredTexture)

self.outputPool = outputPool
self.outputPoolAuxiliaryAttributes = [
    kCVPixelBufferPoolAllocationThresholdKey as String: 6
] as CFDictionary
var preallocatedBuffers: [CVPixelBuffer] = []
for _ in 0 ..< 4 {
    var pixelBuffer: CVPixelBuffer?
    if CVPixelBufferPoolCreatePixelBufferWithAuxAttributes(
        kCFAllocatorDefault,
        outputPool,
        self.outputPoolAuxiliaryAttributes,
        &pixelBuffer
    ) == kCVReturnSuccess, let pixelBuffer {
        preallocatedBuffers.append(pixelBuffer)
    }
}
preallocatedBuffers.removeAll()
func render(
    primary: VideoFrameSource,
    secondary: VideoFrameSource?,
    mixFactor: Float,
    animationTime: Double,
    completion: @escaping (ProcessedVideoFrame?) -> Void
) {
    guard !self.isRendering else {
        return
    }

let retainedPixelBuffers = [
    primary.pixelBuffer, effectiveSecondary.pixelBuffer, outputPixelBuffer
]
let retainedTextures = [
    primaryTextures.y, primaryTextures.cbcr,
    secondaryTextures.y, secondaryTextures.cbcr, outputTexture
]
self.isRendering = true
commandBuffer.addCompletedHandler { [weak self] commandBuffer in
    let processedFrame: ProcessedVideoFrame?
    if commandBuffer.status == .completed {
        processedFrame = ProcessedVideoFrame(pixelBuffer: outputPixelBuffer)
    } else {
        processedFrame = nil
    }
    self?.mediaQueue.async { [weak self] in
        guard let self else {
            return
        }
        self.isRendering = false
        withExtendedLifetime(retainedPixelBuffers) {
            withExtendedLifetime(retainedTextures) {
                completion(processedFrame)
            }
        }
    }
}
commandBuffer.commit()

let histogramSize = calculation.histogramSize(forSourceFormat: input.pixelFormat)
for i in 0 ..< lutCount {
    let col = i % gridSize.width
    let row = i / gridSize.width
    calculation.clipRectSource = MTLRegionMake2D(
        col * tileSize.width, row * tileSize.height,
        tileSize.width, tileSize.height
    )
    calculation.encode(to: commandBuffer, sourceTexture: input,
                       histogram: histogramBuffer,
                       histogramOffset: i * histogramSize)
}
guard let computeCommandEncoder = commandBuffer.makeComputeCommandEncoder() else {
    return nil
}
guard let pipelineState = self.pipelineState else {
    return nil
}
var parameters = MediaEditorEnhanceLUTGeneratorParameters(
    histogramBins: UInt32(binCount),
    clipLimit: UInt32(clipLimitValue),
    totalPixelCountPerTile: UInt32(tileSize.width * tileSize.height),
    numberOfLUTs: UInt32(lutCount)
)
computeCommandEncoder.setComputePipelineState(pipelineState)
computeCommandEncoder.setBuffer(histogramBuffer, offset: 0, index: 0)
computeCommandEncoder.setBytes(&parameters,
    length: MemoryLayout<MediaEditorEnhanceLUTGeneratorParameters>.size, index: 1)

func process(input: MTLTexture, lookupTexture: MTLTexture,
             value: simd_float1, gridSize: simd_float2,
             device: MTLDevice, commandBuffer: MTLCommandBuffer) -> MTLTexture? {
    self.setupVerticesBuffer(device: device)
    let width = input.width
    let height = input.height
    if self.cachedTexture == nil {
        let textureDescriptor = MTLTextureDescriptor()
        textureDescriptor.textureType = .type2D
        textureDescriptor.width = width
        textureDescriptor.height = height
        textureDescriptor.pixelFormat = input.pixelFormat
        textureDescriptor.storageMode = .private
        textureDescriptor.usage = [.shaderRead, .shaderWrite, .renderTarget]
        guard let texture = device.makeTexture(descriptor: textureDescriptor) else {
            return input
        }
        self.cachedTexture = texture
    }
    let renderPassDescriptor = MTLRenderPassDescriptor()
    renderPassDescriptor.colorAttachments[0].texture = self.cachedTexture!
    renderPassDescriptor.colorAttachments[0].loadAction = .dontCare
    renderPassDescriptor.colorAttachments[0].storeAction = .store

public func beginCameraSwitch() {
    guard let cameraPreviewView = self.cameraPreviewView,
          self.cameraBlurView == nil else {
        return
    }
    if let snapshot = cameraPreviewView.snapshotView(afterScreenUpdates: false) {
        self.cameraSnapshotView = snapshot
        self.addSubview(snapshot)
    }
    let blurView = BlurView(effect: nil)
    blurView.clipsToBounds = true
    blurView.frame = self.bounds
    blurView.layer.cornerRadius = self.bounds.width / 2.0
    self.addSubview(blurView)
    UIView.transition(with: self, duration: 0.4,
                      options: [.transitionFlipFromLeft, .curveEaseOut]) {
        blurView.effect = UIBlurEffect(style: .dark)
    }
    self.cameraBlurView = blurView
}
public func commitCameraSwitch() {
    if let cameraBlurView = self.cameraBlurView {
        self.cameraBlurView = nil
        UIView.animate(withDuration: 0.4) {
            cameraBlurView.effect = nil
        }

let transitionContentSourceFrame = contentTransition.sourceView.convert(
    contentTransition.sourceRect, to: transitionContentSuperview
)
let transitionContentDestinationFrame = self.view.convert(
    self.view.bounds, to: transitionContentSuperview
)
let transitionContentSelfSourceFrame = contentTransition.sourceView.convert(
    contentTransition.sourceRect, to: self.view
)
let transitionContentSelfDestinationFrame = self.view.convert(
    self.view.bounds, to: self.view
)
let screenCornerRadius: CGFloat = validLayout.layout.deviceMetrics.screenCornerRadius
transitionContentView.frame = transitionContentSourceFrame
contentTransition.updateView(transitionContentView,
    GalleryItemScrubberTransition.Content.TransitionState(
        sourceSize: transitionContentSourceFrame.size,
        destinationSize: transitionContentDestinationFrame.size,
        destinationCornerRadius: screenCornerRadius, progress: 0.0
    ), .immediate)
transitionSelfContentView.frame = transitionContentSelfSourceFrame
contentTransition.updateView(transitionSelfContentView,
    GalleryItemScrubberTransition.Content.TransitionState(
        sourceSize: transitionContentSelfSourceFrame.size,
        destinationSize: transitionContentSelfDestinationFrame.size,
        destinationCornerRadius: screenCornerRadius, progress: 0.0
    ), .immediate)
let transition: ContainedViewLayoutTransition = .animated(duration: 0.25, curve: .spring)
transition.updateFrame(view: transitionContentView,
                       frame: transitionContentDestinationFrame)

if let transitionViewImpl = transitionView?.makeView() {
    fixScale(layer: transitionViewImpl.layer)
    transitionViewsImpl.append(transitionViewImpl)
    let transitionSourceContainerView = UIView(frame: self.bounds)
    transitionSourceContainerView.isUserInteractionEnabled = false
    self.componentContainerView.insertSubview(
        transitionSourceContainerView, aboveSubview: self.itemsContainerView
    )
    transitionSourceContainerView.addSubview(transitionViewImpl)
    if let insertCloneTransitionView = transitionView?.insertCloneTransitionView {
        if let transitionCloneViewImpl = transitionView?.makeView() {
            fixScale(layer: transitionCloneViewImpl.layer)
            transitionViewsImpl.append(transitionCloneViewImpl)
            transitionCloneMasterView.isUserInteractionEnabled = false
            let globalFrame = transitionCloneMasterView.convert(
                transitionCloneMasterView.bounds, to: nil
            )
            insertCloneTransitionView(transitionCloneMasterView)
            if let newParentView = transitionCloneMasterView.superview {
                newParentView.frame = newParentView.convert(globalFrame, from: nil)
            }
            self.transitionCloneContainerView.addSubview(transitionCloneViewImpl)
            transitionSourceContainerView.layer.animateAlpha(
                from: 1.0, to: 0.0, duration: 0.16, removeOnCompletion: false
            )
        }
    }
}

private func itemProgressMode() -> StoryContentItem.ProgressMode {
    guard let component = self.component else {
        return .pause
    }
    if component.pinchState != nil {
        return .pause
    }
    if self.verticalPanState != nil {
        return .pause
    }
    if self.contextController != nil {
        return .blurred
    }
    if self.inputPanelExternalState.isEditing || component.isProgressPaused ||
       self.sendMessageContext.actionSheet != nil ||
       self.sendMessageContext.isViewingAttachedStickers ||
       self.sendMessageContext.audioRecorderValue != nil ||
       self.sendMessageContext.videoRecorderValue != nil ||
       self.viewListDisplayState != .hidden {
        return .pause
    }
    if let reactionContextNode = self.reactionContextNode,
       reactionContextNode.isReactionSearchActive {
        return .pause
    }
    if self.privacyController != nil {
        return .pause
    }

@objc public func gestureRecognizer(
    _ gestureRecognizer: UIGestureRecognizer,
    shouldRequireFailureOf otherGestureRecognizer: UIGestureRecognizer
) -> Bool {
    if gestureRecognizer is UITapGestureRecognizer {
        if otherGestureRecognizer is UIPanGestureRecognizer {
            return true
        }
        return false
    } else {
        return false
    }
}
public func gestureRecognizer(
    _ gestureRecognizer: UIGestureRecognizer,
    shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer
) -> Bool {
    if gestureRecognizer is UIPanGestureRecognizer {
        if let otherGestureRecognizer = otherGestureRecognizer as? UIPanGestureRecognizer {
            if otherGestureRecognizer.view is UIScrollView {
                return true
            }
            if let component = self.component,
               let viewList = self.viewLists[component.slice.item.id],
               let viewListView = viewList.view.view as? StoryItemSetViewListComponent.View,
               otherGestureRecognizer.view === viewListView {
                return true
            }
        }
        return false
    } else {
        return false
    }
}

if self.currentIndex >= 0 && self.currentIndex < self.items.count {
    let preloadSpan: Int = 2
    for i in max(0, self.currentIndex - preloadSpan) ...
             min(self.currentIndex + preloadSpan, self.items.count - 1) {
        if self.items[i].representations.isEmpty {
            continue
        }
        validIds.append(self.items[i].id)
        var itemNode: PeerInfoAvatarListItemNode?
        var wasAdded = false
        if let current = self.itemNodes[self.items[i].id] {
            itemNode = current
            if update {
                var synchronous = synchronous && i == self.currentIndex
                if case .custom = self.items[i], self.updateCustomItemsOnlySynchronously {
                    synchronous = true
                }
                current.setup(item: self.items[i], isMain: i == 0,
                    synchronous: synchronous && i == self.currentIndex,
                    fullSizeOnly: self.firstFullSizeOnly && i == 0)
            }
        } else if let peer = self.peer {
            wasAdded = true
            let addedItemNode = PeerInfoAvatarListItemNode(context: self.context, peer: peer)
            itemNode = addedItemNode
            addedItemNode.setup(item: self.items[i], isMain: i == 0,
                progress: i == 0 ? self.additionalEntryProgress : nil,
                synchronous: (i == 0 && i == self.currentIndex) ||
                    (synchronous && i == self.currentIndex),
                fullSizeOnly: self.firstFullSizeOnly && i == 0)

let frame = PendingVideoFrame(
    source: source,
    rawPresentationTime: rawPresentationTime,
    presentationTime: rawPresentationTime - self.videoTimelineOffset
)
if var retiming = self.singleCameraSwitch,
   retiming.isCommitted,
   !retiming.isResolved,
   retiming.to == position {
    if retiming.heldFrame == nil {
        retiming.heldFrame = frame
    }
    self.singleCameraSwitch = retiming
    return
}
let isFirstSwitchFrame = self.consumeFirstSingleCameraSwitchVideoFrameIfNeeded(frame)
self.submitVideoFrame(frame, allowPastStopBoundary: isFirstSwitchFrame)
}
private func submitVideoFrame(_ frame: PendingVideoFrame,
                              allowPastStopBoundary: Bool = false) {
    if let lastVideoTime = self.lastVideoTime,
       frame.presentationTime <= lastVideoTime {
        return
    }
    if self.stopRequested && self.videoReachedStopTarget &&
       !allowPastStopBoundary {
        return
    }