closeTexture unregistered the texture but kept it in the plugin's map with its last frame (33 MB at 4K) until the engine went away, and the texture went on taking and announcing frames pushed to its pointer. Kitedesk makes a texture per display, so each display switch and closed tab leaked a frame. closeTexture now takes the texture out of the map and closes it: frames pushed afterwards are dropped and not announced, the engine gets no frame any more, and the frames, the handed buffers and the pool go. As on Windows (B252), a texture closed without "recycle" may still get frames through the pointer from getTexturePtr (a tab moving to another window keeps its session's pointer), so it is kept for the process lifetime and its address is never another texture's; with "recycle" it is freed once the engine has unregistered it. The textures still open when the engine goes away are closed and kept the same way: the registry's reference to them used to keep them alive, announcing every frame to a registry without an engine. A closed texture no longer holds the registry. Tests: closing_frees_frame_buffers (634 MB more after 20 4K textures, now 0.2 MB), closed_texture_drops_late_frames, closing_keeps_only_unrecycled_textures, open_textures_outlive_their_engine and frames_racing_close pass: 13 of 13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
160 lines
6.3 KiB
Swift
160 lines
6.3 KiB
Swift
//
|
|
// TextRgba.swift
|
|
// texture_rgba_renderer
|
|
//
|
|
// Created by kingtous on 2023/2/17.
|
|
//
|
|
// Modified by the Kitedesk fork (2026, T-4204): frames go into the
|
|
// IOSurface-backed buffers of a pool, which does not hand out again the
|
|
// buffers last handed to the engine, and are copied outside the queue the
|
|
// raster thread waits on; rows are copied one by one when their stride
|
|
// differs from the pixel buffer's; frames are announced on the main queue;
|
|
// close() drops the frames pushed after it and lets the buffers go.
|
|
//
|
|
|
|
import Foundation
|
|
import FlutterMacOS
|
|
import CoreVideo
|
|
|
|
@objc public class TextRgba: NSObject, FlutterTexture {
|
|
public var textureId: Int64 = -1
|
|
// Main thread only. Nil once closed.
|
|
private var registry: FlutterTextureRegistry?
|
|
private var data: CVPixelBuffer?
|
|
private var width: Int = 0
|
|
private var height: Int = 0
|
|
private let queue = DispatchQueue(label: "text_rgba_sync_queue")
|
|
// Buffers of width x height. With data, width, height, handed and closed, guarded by queue.
|
|
private var pool: CVPixelBufferPool?
|
|
private var closed = false
|
|
// The buffers last handed to the engine, the newest last: not written again.
|
|
private var handed: [CVPixelBuffer] = []
|
|
// 2: the engine (3.24.5) drops its CVMetalTexture at once, so GPU work may still read the buffer handed before the drawn one (flutter#157379, inferred).
|
|
private static let handedFramesKept = 2
|
|
|
|
public static func new(registry: FlutterTextureRegistry?) -> TextRgba {
|
|
let textRgba = TextRgba()
|
|
textRgba.registry = registry
|
|
textRgba.textureId = registry?.register(textRgba) ?? -1
|
|
return textRgba
|
|
}
|
|
|
|
public func copyPixelBuffer() -> Unmanaged<CVPixelBuffer>? {
|
|
queue.sync {
|
|
if (data == nil) {
|
|
return nil
|
|
}
|
|
if (handed.last !== data) {
|
|
handed.append(data!)
|
|
if (handed.count > TextRgba.handedFramesKept) {
|
|
handed.removeFirst()
|
|
}
|
|
}
|
|
return Unmanaged.passRetained(data!)
|
|
}
|
|
}
|
|
|
|
private func _markFrameAvaliable(buffer: UnsafePointer<UInt8>, len: Int, width: Int, height: Int, stride_align: Int) -> Bool {
|
|
// The rows of buffer are padded to stride_align.
|
|
let row = width * 4
|
|
let stride = stride_align > 1 ? (row + stride_align - 1) / stride_align * stride_align : row
|
|
guard width > 0 && height > 0 && len >= stride * height else {
|
|
return false
|
|
}
|
|
var pixelBufferCopy: CVPixelBuffer?
|
|
guard let pool = poolOf(width: width, height: height),
|
|
CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pool, &pixelBufferCopy) == kCVReturnSuccess else {
|
|
return false
|
|
}
|
|
|
|
// Outside the queue: the raster thread waits on it for the newest frame.
|
|
CVPixelBufferLockBaseAddress(pixelBufferCopy!, [])
|
|
let ptr = CVPixelBufferGetBaseAddress(pixelBufferCopy!)!
|
|
let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBufferCopy!)
|
|
if (bytesPerRow == stride) {
|
|
memcpy(ptr, buffer, stride * height)
|
|
} else {
|
|
for y in 0..<height {
|
|
memcpy(ptr + y * bytesPerRow, buffer + y * stride, row)
|
|
}
|
|
}
|
|
CVPixelBufferUnlockBaseAddress(pixelBufferCopy!, [])
|
|
let open = queue.sync { () -> Bool in
|
|
if (closed) {
|
|
return false
|
|
}
|
|
self.data = pixelBufferCopy
|
|
return true
|
|
}
|
|
if open && textureId != -1 {
|
|
// On the platform (main) thread, which the engine checks.
|
|
DispatchQueue.main.async {
|
|
self.registry?.textureFrameAvailable(self.textureId)
|
|
}
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// The pool of buffers of width x height, a new one for a new size; none once closed.
|
|
private func poolOf(width: Int, height: Int) -> CVPixelBufferPool? {
|
|
queue.sync {
|
|
if (!closed && (pool == nil || self.width != width || self.height != height)) {
|
|
pool = TextRgba.newPool(width: width, height: height)
|
|
self.width = width
|
|
self.height = height
|
|
}
|
|
return pool
|
|
}
|
|
}
|
|
|
|
// Main thread: closeTexture, or the engine going away. Frames pushed from now on are
|
|
// dropped and not announced, the engine gets no frame any more, and the buffers go.
|
|
func close() {
|
|
registry = nil
|
|
queue.sync {
|
|
closed = true
|
|
data = nil
|
|
handed = []
|
|
pool = nil
|
|
}
|
|
}
|
|
|
|
@objc public func markFrameAvaliableRaw(buffer: UnsafePointer<UInt8>, len: Int, width: Int, height: Int, stride_align: Int) -> Bool {
|
|
_markFrameAvaliable(buffer: buffer, len: len, width: width, height: height, stride_align: stride_align)
|
|
}
|
|
|
|
|
|
private static func newPool(width: Int, height: Int) -> CVPixelBufferPool? {
|
|
// macOS only support 32BGRA currently.
|
|
let dict: [String: Any] = [
|
|
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
|
|
kCVPixelBufferWidthKey as String: width,
|
|
kCVPixelBufferHeightKey as String: height,
|
|
kCVPixelBufferIOSurfacePropertiesKey as String: [String: Any](),
|
|
kCVPixelBufferMetalCompatibilityKey as String: true,
|
|
kCVPixelBufferOpenGLCompatibilityKey as String: true,
|
|
// https://developer.apple.com/forums/thread/712709
|
|
kCVPixelBufferBytesPerRowAlignmentKey as String: 64
|
|
]
|
|
// The handed buffers, the newest frame and the one being written.
|
|
let poolDict: [String: Any] = [kCVPixelBufferPoolMinimumBufferCountKey as String: handedFramesKept + 2]
|
|
var pool: CVPixelBufferPool?
|
|
CVPixelBufferPoolCreate(kCFAllocatorDefault, poolDict as CFDictionary, dict as CFDictionary, &pool)
|
|
return pool
|
|
}
|
|
|
|
@objc public func markFrameAvaliable(data: Data, width: Int, height: Int, stride_align: Int) -> Bool {
|
|
data.withUnsafeBytes { buffer in
|
|
markFrameAvaliableRaw(
|
|
buffer: buffer.baseAddress!.assumingMemoryBound(to: UInt8.self),
|
|
len: data.count,
|
|
width: width,
|
|
height: height,
|
|
stride_align: stride_align)
|
|
}
|
|
}
|
|
}
|
|
|
|
|