Compare commits

...
Sign in to create a new pull request.

11 commits

Author SHA1 Message Date
b87d45fd09 macos: drain an autorelease pool around each frame (Kitedesk T-4204)
FlutterRgbaRendererPluginOnRgba runs on the caller's thread, a Kitedesk
video thread, which has no autorelease pool and lives as long as the
session: an object autoreleased there would stay until the session ends
(pointed out in upstream PR #2). Each frame now runs in an @autoreleasepool.

On macOS 26.5.2 the frame path autoreleases nothing on that thread, before
and after this series (frames_leave_no_autoreleased_objects passes on
50efc18e too), so this is a guard: a probe saw CoreVideo autorelease objects
when a process first made an IOSurface on such a thread, and the engine's
registrar logs with NSLog for a frame announced to it after its engine is
gone, which the old code did on the video thread.

Tests: 13 of 13 pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
6c3425539f macos: let closed textures' buffers go, keep closed identities (Kitedesk T-4204)
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>
2026-11-15 09:56:22 +09:00
2a36975b62 macos: announce frames on the main queue (Kitedesk T-4204)
textureFrameAvailable was called on the thread that pushed the frame, a
Kitedesk video thread. The engine wants it on the platform thread
(Shell::OnPlatformViewMarkTextureFrameAvailable checks it, engine
a18df97c), as it wants registerTexture and unregisterTexture, which already
run there; Kitedesk's own GPU texture (KdMatoyaTexture.swift) posts its
notices the same way.

The notice is now posted to the main queue; the registry is only used on the
main thread.

Tests: frames_are_announced_on_the_main_thread passes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
11478d230c macos: copy frames outside the queue the raster thread waits on (Kitedesk T-4204)
The whole frame, buffer and copy included, ran in queue.sync, and the
engine's raster thread takes the newest frame in copyPixelBuffer on the same
queue, so it waited for the copy: R T-4201 measured a p90 of 4.0 ms at 60 Hz
(6.5 ms at 120 Hz), and the raster thread draws the whole window.

The frame is now copied into its pool buffer outside the queue; the queue
only guards the pool, the newest frame and the handed buffers, so it is held
for a pointer swap.

Tests: raster_does_not_wait_for_copies passes (4K frames back to back: the
raster's median wait was 0.9 to 1.1 ms in three runs, up to 537 of 600 calls
over 1 ms; now 0.003 ms, at most 0.032 ms).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
7af0d01118 macos: take frame buffers from a pool, keep the two last handed (Kitedesk T-4204)
Every frame made a new IOSurface-backed CVPixelBuffer (33 MB at 4K), and
the engine let it go soon after. R T-4201 measured 2.2 to 7.8 ms per 4K
frame alone, up to 110 ms, and a 6.5 ms median at 60 fps; upstream #16922
saw 37% of the CPU and memory swings of 1.85 to 2.43 GB.

Frames now go into the buffers of a CVPixelBufferPool with IOSurface
properties, made again when the frame size changes. A pool hands a buffer
out again as soon as nobody holds it, even while its IOSurface backs a live
Metal texture (measured), and engine a18df97c lets go of the pixel buffer and
of its CVMetalTexture as soon as it has the Metal texture, which Skia then
draws until the next frame. So the texture keeps the buffers it last handed
to the engine: the one drawn, and the one drawn before it, which GPU work
queued meanwhile may still read (the plugin cannot see when the GPU is done,
flutter#157379; inferred). With the newest frame and the one being written, a
texture uses three buffers while the engine keeps up and four when it falls
behind.

Tests: pool_reuses_buffers passes (60 IOSurfaces for 60 frames of a size,
now at most 4). drawn_frame_is_not_overwritten fails when no handed buffer
is kept, frame_drawn_before_is_not_overwritten when one is; both pass with
two.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
2c334da6f9 macos: copy rows of another stride one by one (Kitedesk T-4204)
FlutterRgbaRendererPluginOnRgba gets rows padded to stride_align, and the
pixel buffer has its own bytes per row ((width * 4 + 63) & ~63 on Apple
Silicon). The frame was copied in one memcpy of len bytes, so rows came out
shifted whenever the two differ: Kitedesk sends stride_align 1 for a session
drawn in software, whose "all displays" view still uses textures, and any
width that is not a multiple of 16 then shears (1366, 1001, 1279, 3838). A
stride above the pixel buffer's wrote past its data.

Rows are now copied one by one, width * 4 bytes each, when the strides
differ, and in one memcpy of the rows otherwise. A frame shorter than its
rows promise is dropped instead of being read past its end.

Tests: rows_follow_the_frame_stride and short_frames_are_dropped pass; the
other eight that failed still do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
9a377b6155 macos: add headless texture tests (Kitedesk T-4204)
Standalone Objective-C tests for the macOS texture, built against
FlutterMacOS.framework of the active Flutter SDK by macos/test/run_tests.sh
(optionally with ASan or TSan). The plugin sources are compiled into the
test; the plugin registers through a fake plugin registrar and is driven
through handleMethodCall:result:. The fake engine follows
FlutterTextureRegistrar.mm and FlutterExternalTexture.mm of engine a18df97c:
the texture id is the texture's address, the registrar keeps registered
textures, and copyPixelBuffer is wrapped into a Metal texture whose
CVMetalTexture and pixel buffer are released at once while the Metal texture
stays drawn. Frames come through FlutterRgbaRendererPluginOnRgba on a thread
without an autorelease pool. Memory is the task's phys_footprint, which counts
IOSurfaces, read after the engine's CVMetalTextureCache has let go of what it
wrapped (it keeps that until it makes a texture a second later, measured);
it is not checked under ASan, whose shadow of each new IOSurface mapping
counts in it. No app, window or screen capture.

On 50efc18e ten of the thirteen tests fail (Mac mini M4, macOS 26.5.2):
every frame gets a new IOSurface (60 for 60 frames), the raster thread waits
for the copy (median 0.9 to 1.1 ms in three runs, up to 537 of 600 calls over
1 ms, with 4K frames), frames are announced off the main thread, closed
textures keep their last frame (634 MB more after 20 4K textures) and still
take and announce late frames, a texture closed with recycle is never freed,
and rows of another stride than the pixel buffer's are copied in one piece
(shifted rows for 1366, 1001, 1279 and 3838 pixels wide with stride_align 1,
and 1001 with 256), short frames included. The two tests on frames the engine
was handed pass, as no buffer is ever written twice yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:56:22 +09:00
50efc18ec5 G26: keep Windows textures alive through asynchronous unregister
Retain closed raw-pointer identities for late frames, release frame buffers
after engine completion, and serialize termination with decoded frame writes.
Add native regression controls for held raster buffers, inline completion,
failed raster posts, missing registrations, teardown and concurrent closure.

B252; Apache-2.0 dependency license and upstream history preserved.
2026-10-29 12:13:44 +09:00
8cd34a80ff linux: recycle closed textures per engine, closeTexture(recycle:) (Kitedesk B212)
Each session created a new TextureRgba and closeTexture never released it, so
the engine's FlPixelBufferTexture kept its GL texture (one frame of GPU or,
with llvmpipe, process memory per session). Releasing the object is not safe:
FlPixelBufferTexture deletes its GL texture in dispose without selecting a GL
context, so a release from another window deletes that window's texture of
the same name (upstream PR #2 turned the remaining window white).

closeTexture(key, recycle: true) now keeps the texture in a list of the
plugin instance, i.e. of the engine (window) that created it, and the next
createTexture of that engine registers it again. Its GL texture is only ever
touched by that engine's populate in its own context, nothing is released,
and the GL memory is bounded by the number of textures a window had open at
once. When the engine goes away the recycled textures stay referenced for the
same reason. Without recycle (old callers, or a tab that moves to another
window while its session still holds the pointer) a closed texture stays
terminated and is never handed out again.

With no frame waiting, copy_pixels hands out one transparent pixel instead
of no buffer, so a recycled texture cannot show the last frame of its previous
session before the first new frame.

Dart: closeTexture(int key, {bool recycle = false}) sends "recycle"; other
platforms ignore it. Tests: all ten Linux lifecycle tests pass (clang and
gcc, -Wall -Werror, also under ASan/UBSan); Dart 4/4.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-11 15:38:06 +09:00
48fa1d7ddf linux: free frame buffers on closeTexture and in finalize (Kitedesk B212)
closeTexture marked the texture terminated but kept the frame last handed to
the engine and any frame still waiting, and TextureRgba had no finalize, so
each closed session kept one or two frame-sized buffers forever (2 x
width x height x 4 bytes measured per 1080p session).

terminate now frees both buffers under the texture mutex: the texture is
already unregistered and OnRgba stops copying once terminated is set. A
finalize frees them as well. GObject and GL lifetime are unchanged here.

Tests: close_frees_frame_buffers, closed_texture_ignores_late_frames,
finalize_frees_frame_buffers and frames_racing_close pass (also under ASan);
the four recycling tests still fail.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-11 15:34:27 +09:00
ec78a48bd9 linux: add texture lifecycle tests (Kitedesk B212)
Standalone C++ tests for the Linux texture, built against the engine of the
active Flutter SDK by linux/test/run_tests.sh (optionally with ASan/UBSan).
The plugin source is compiled into the test and driven through a real
FlMethodChannel on fake engine objects (binary messenger, texture registrar
with the reference rules of engine a18df97c, plugin registrar); frame
buffers copied with new[] are counted.

On 42797e0f eight of the ten tests fail: closing a texture keeps both frame
buffers, the GObject has no finalize, and closed textures are never reused,
so every session leaves a frame buffer and an engine GL texture behind.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-11 15:33:50 +09:00
23 changed files with 3204 additions and 45 deletions

View file

@ -1,3 +1,4 @@
// Modified by the Kitedesk fork (2026, B212/B252/T-4204): closeTexture ownership.
import 'dart:typed_data'; import 'dart:typed_data';
export './texture_rgba_ffi.dart' show Native; export './texture_rgba_ffi.dart' show Native;
@ -17,9 +18,21 @@ class TextureRgbaRenderer {
/// Close a texture with unique identifier [key]. /// Close a texture with unique identifier [key].
/// ///
/// Pass [recycle] = true only when nothing calls `onRgba` with the pointer
/// from [getTexturePtr] any more. On Linux the texture is then kept for the
/// next [createTexture] of the same window (Kitedesk fork, B212).
/// On Windows it may be destroyed only after the engine finishes unregistering
/// it. Without [recycle], Windows retains its closed identity for the process
/// lifetime so late raw-pointer frames cannot reach freed or reused memory;
/// its frame buffers are freed after unregistering (Kitedesk fork, B252).
/// macOS frees the frame buffers on closing and treats [recycle] as Windows
/// does (Kitedesk fork, T-4204).
/// Other platforms ignore [recycle].
///
/// @return a boolean to indicate whether the operation is sucessfully executed. /// @return a boolean to indicate whether the operation is sucessfully executed.
Future<bool> closeTexture(int key) { Future<bool> closeTexture(int key, {bool recycle = false}) {
return TextureRgbaRendererPlatform.instance.closeTexture(key); return TextureRgbaRendererPlatform.instance
.closeTexture(key, recycle: recycle);
} }
/// Provide the rgba data to the texture. /// Provide the rgba data to the texture.

View file

@ -1,3 +1,4 @@
// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`.
// ignore: unused_import, unnecessary_import // ignore: unused_import, unnecessary_import
import 'dart:io'; import 'dart:io';
// Compatible with lint in Flutter 3.0.5 // Compatible with lint in Flutter 3.0.5
@ -30,9 +31,9 @@ class MethodChannelTextureRgbaRenderer extends TextureRgbaRendererPlatform {
} }
@override @override
Future<bool> closeTexture(int key) async { Future<bool> closeTexture(int key, {bool recycle = false}) async {
return await methodChannel return await methodChannel.invokeMethod<bool>(
.invokeMethod<bool>('closeTexture', {"key": key}) ?? 'closeTexture', {"key": key, "recycle": recycle}) ??
false; false;
} }

View file

@ -1,3 +1,4 @@
// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`.
import 'dart:typed_data'; import 'dart:typed_data';
import 'package:flutter/foundation.dart'; import 'package:flutter/foundation.dart';
@ -35,7 +36,7 @@ abstract class TextureRgbaRendererPlatform extends PlatformInterface {
throw UnimplementedError('createTexture() has not been implemented.'); throw UnimplementedError('createTexture() has not been implemented.');
} }
Future<bool> closeTexture(int key) { Future<bool> closeTexture(int key, {bool recycle = false}) {
throw UnimplementedError('closeTexture() has not been implemented.'); throw UnimplementedError('closeTexture() has not been implemented.');
} }

View file

@ -1,3 +1,8 @@
// Modified by the Kitedesk fork (2026, B212): frame buffers are freed when the
// texture is closed and when the object is finalized; a closed texture can be
// restarted for reuse; with no frame waiting, one transparent pixel is handed
// out instead of no buffer.
#ifndef TEXTURE_RGBA_RENDERER_H #ifndef TEXTURE_RGBA_RENDERER_H
#define TEXTURE_RGBA_RENDERER_H #define TEXTURE_RGBA_RENDERER_H
@ -40,9 +45,34 @@ G_DEFINE_TYPE(TextureRgba, texture_rgba,
TextureRgba)) TextureRgba))
// Frees the frame waiting for the next raster frame and the frame last handed
// to the engine. Call with the mutex held, or when no other thread can use the
// texture any more.
static void texture_rgba_free_buffers(TextureRgba* self) {
if (g_atomic_int_get(&self->buffer_ready)) {
// Not handed to the engine yet; prior_buffer is the older frame.
delete[] self->buffer;
}
delete[] self->prior_buffer;
self->buffer = nullptr;
self->prior_buffer = nullptr;
g_atomic_int_set(&self->buffer_ready, FALSE);
}
static void texture_rgba_terminate(TextureRgba* self) { static void texture_rgba_terminate(TextureRgba* self) {
g_mutex_lock(&self->mutex); g_mutex_lock(&self->mutex);
g_atomic_int_set(&self->terminated, TRUE); g_atomic_int_set(&self->terminated, TRUE);
// The texture is unregistered, so the engine reads neither frame again, and
// OnRgba stops copying frames once terminated is set.
texture_rgba_free_buffers(self);
g_mutex_unlock(&self->mutex);
}
// Makes a texture that was closed for recycling usable again (its frame
// buffers were freed when it was closed).
static void texture_rgba_restart(TextureRgba* self) {
g_mutex_lock(&self->mutex);
g_atomic_int_set(&self->terminated, FALSE);
g_mutex_unlock(&self->mutex); g_mutex_unlock(&self->mutex);
} }
@ -89,6 +119,14 @@ static gboolean texture_rgba_copy_pixels(FlPixelBufferTexture* texture,
*error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), -1, "the texture is already terminated, ignoring."); *error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), -1, "the texture is already terminated, ignoring.");
return FALSE; return FALSE;
} else { } else {
// No frame yet (first raster frame, or a recycled texture). Hand out one
// transparent pixel instead of no buffer: the engine would otherwise
// re-specify the GL texture without data and could show its previous
// content, e.g. the last frame of the session that used this texture.
static const uint8_t no_frame[4] = {0, 0, 0, 0};
*out_buffer = no_frame;
*width = 1;
*height = 1;
g_mutex_unlock(&self->mutex); g_mutex_unlock(&self->mutex);
// *error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), 1, "waiting for new incoming images."); // *error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), 1, "waiting for new incoming images.");
return TRUE; return TRUE;
@ -137,8 +175,16 @@ static TextureRgba *texture_rgba_new(FlTextureRegistrar* registrar)
return texture; return texture;
} }
static void texture_rgba_finalize(GObject* object) {
TextureRgba* self = TEXTURE_RGBA(object);
texture_rgba_free_buffers(self);
g_mutex_clear(&self->mutex);
G_OBJECT_CLASS(texture_rgba_parent_class)->finalize(object);
}
static void texture_rgba_class_init(TextureRgbaClass *klass) static void texture_rgba_class_init(TextureRgbaClass *klass)
{ {
G_OBJECT_CLASS(klass)->finalize = texture_rgba_finalize;
FL_PIXEL_BUFFER_TEXTURE_CLASS(klass)->copy_pixels = texture_rgba_copy_pixels; FL_PIXEL_BUFFER_TEXTURE_CLASS(klass)->copy_pixels = texture_rgba_copy_pixels;
} }

24
linux/test/run_tests.sh Executable file
View file

@ -0,0 +1,24 @@
#!/usr/bin/env bash
# Kitedesk fork, 2026: builds and runs linux/test/texture_rgba_renderer_plugin_test.cc
# against the Linux engine of the Flutter SDK on PATH (or FLUTTER_ROOT).
# The test does not open a display or a GL context.
# run_tests.sh -Wall -Werror build, like the plugin in an app build
# run_tests.sh --asan the same with AddressSanitizer and UBSan
# OUT_DIR (default: a new temporary directory) receives the test binary.
set -euo pipefail
here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
root=${FLUTTER_ROOT:-$(dirname "$(dirname "$(readlink -f "$(command -v flutter)")")")}
engine=$root/bin/cache/artifacts/engine/linux-x64
[ -f "$engine/libflutter_linux_gtk.so" ] || { echo "no Linux engine in $engine (run flutter precache --linux)" >&2; exit 2; }
out=${OUT_DIR:-$(mktemp -d)}
mkdir -p "$out"
flags=(-std=gnu++14 -Wall -Werror -O1 -g -DFLUTTER_PLUGIN_IMPL)
if [ "${1:-}" = --asan ]; then
flags+=(-fsanitize=address,undefined -fno-omit-frame-pointer -fno-sanitize-recover=undefined)
export ASAN_OPTIONS=${ASAN_OPTIONS:-detect_leaks=0}
fi
# shellcheck disable=SC2046
"${CXX:-clang++}" "${flags[@]}" -I"$engine" -I"$here/../include" $(pkg-config --cflags gtk+-3.0) \
"$here/texture_rgba_renderer_plugin_test.cc" -o "$out/texture_rgba_renderer_plugin_test" \
-L"$engine" -Wl,-rpath,"$engine" -lflutter_linux_gtk $(pkg-config --libs gtk+-3.0) -pthread
"$out/texture_rgba_renderer_plugin_test"

View file

@ -0,0 +1,836 @@
// Kitedesk fork, 2026: lifecycle tests for the Linux texture of this plugin
// (Kitedesk backlog B212). Licensed under the Apache License, Version 2.0,
// like the rest of this package.
//
// The plugin source is compiled into this program and driven through a real
// FlMethodChannel on fake engine objects: a binary messenger, a texture
// registrar with the reference rules of the Flutter 3.24 engine, and a plugin
// registrar. Frame buffers that the plugin copies with new[] are counted.
// The engine's GL work (fl_pixel_buffer_texture_populate) is replaced by calls
// to the copy_pixels hook it would make; no GL context is needed.
//
// Build and run: linux/test/run_tests.sh [--asan]
#include "../texture_rgba_renderer_plugin.cc"
#include <atomic>
#include <cstdio>
#include <cstdlib>
#include <new>
#include <set>
#include <thread>
namespace {
constexpr int kWidth = 321;
constexpr int kHeight = 123;
constexpr size_t kFrameBytes = static_cast<size_t>(kWidth) * kHeight * 4;
// Live frame buffers: new[] blocks of exactly kFrameBytes (no other code in
// this program allocates that size).
constexpr int kSlots = 4096;
std::atomic_flag g_frames_lock = ATOMIC_FLAG_INIT;
void* g_frames[kSlots];
int g_live_frames = 0;
void lock_frames() {
while (g_frames_lock.test_and_set(std::memory_order_acquire)) {
}
}
void unlock_frames() { g_frames_lock.clear(std::memory_order_release); }
int live_frames() {
lock_frames();
int n = g_live_frames;
unlock_frames();
return n;
}
} // namespace
void* operator new[](size_t size) {
void* p = std::malloc(size ? size : 1);
if (p == nullptr) {
throw std::bad_alloc();
}
if (size == kFrameBytes) {
lock_frames();
for (int i = 0; i < kSlots; i++) {
if (g_frames[i] == nullptr) {
g_frames[i] = p;
g_live_frames++;
break;
}
}
unlock_frames();
}
return p;
}
void operator delete[](void* p) noexcept {
if (p != nullptr) {
lock_frames();
for (int i = 0; i < kSlots; i++) {
if (g_frames[i] == p) {
g_frames[i] = nullptr;
g_live_frames--;
break;
}
}
unlock_frames();
}
std::free(p);
}
void operator delete[](void* p, size_t) noexcept { operator delete[](p); }
// ---------------------------------------------------------------------------
// Fake texture registrar: register takes a reference and keys the texture by
// its address, unregister drops it (fl_texture_registrar.cc @ engine a18df97c).
G_DECLARE_FINAL_TYPE(FakeTextureRegistrar,
fake_texture_registrar,
FAKE,
TEXTURE_REGISTRAR,
GObject)
struct _FakeTextureRegistrar {
GObject parent_instance;
GHashTable* textures; // FlTexture* -> FlTexture* (reference)
GMutex mutex;
gint marks;
};
static void fake_texture_registrar_iface_init(
FlTextureRegistrarInterface* iface);
G_DEFINE_TYPE_WITH_CODE(
FakeTextureRegistrar,
fake_texture_registrar,
G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE(fl_texture_registrar_get_type(),
fake_texture_registrar_iface_init))
static gboolean ftr_register(FlTextureRegistrar* registrar,
FlTexture* texture) {
FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar);
FL_TEXTURE_GET_IFACE(texture)->set_id(texture,
reinterpret_cast<int64_t>(texture));
g_mutex_lock(&self->mutex);
g_hash_table_insert(self->textures, texture, g_object_ref(texture));
g_mutex_unlock(&self->mutex);
return TRUE;
}
static FlTexture* ftr_lookup(FlTextureRegistrar* registrar, int64_t id) {
FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar);
g_mutex_lock(&self->mutex);
FlTexture* texture = static_cast<FlTexture*>(
g_hash_table_lookup(self->textures, reinterpret_cast<gpointer>(id)));
g_mutex_unlock(&self->mutex);
return texture;
}
static gboolean ftr_mark(FlTextureRegistrar* registrar, FlTexture* texture) {
g_atomic_int_inc(&FAKE_TEXTURE_REGISTRAR(registrar)->marks);
return TRUE;
}
static gboolean ftr_unregister(FlTextureRegistrar* registrar,
FlTexture* texture) {
FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar);
g_mutex_lock(&self->mutex);
gboolean removed = g_hash_table_remove(self->textures, texture);
g_mutex_unlock(&self->mutex);
return removed;
}
static void ftr_shutdown(FlTextureRegistrar* registrar) {
FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar);
g_mutex_lock(&self->mutex);
g_hash_table_remove_all(self->textures);
g_mutex_unlock(&self->mutex);
}
static void fake_texture_registrar_iface_init(
FlTextureRegistrarInterface* iface) {
iface->register_texture = ftr_register;
iface->lookup_texture = ftr_lookup;
iface->mark_texture_frame_available = ftr_mark;
iface->unregister_texture = ftr_unregister;
iface->shutdown = ftr_shutdown;
}
static void fake_texture_registrar_dispose(GObject* object) {
FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(object);
g_clear_pointer(&self->textures, g_hash_table_unref);
G_OBJECT_CLASS(fake_texture_registrar_parent_class)->dispose(object);
}
static void fake_texture_registrar_class_init(
FakeTextureRegistrarClass* klass) {
G_OBJECT_CLASS(klass)->dispose = fake_texture_registrar_dispose;
}
static void fake_texture_registrar_init(FakeTextureRegistrar* self) {
self->textures = g_hash_table_new_full(g_direct_hash, g_direct_equal,
nullptr, g_object_unref);
g_mutex_init(&self->mutex);
}
static gboolean registered(FakeTextureRegistrar* self, int64_t ptr) {
return ftr_lookup(FL_TEXTURE_REGISTRAR(self), ptr) != nullptr;
}
// ---------------------------------------------------------------------------
// Fake binary messenger. send_on_channel delivers to the handler registered on
// the peer messenger, like Dart -> engine -> plugin.
G_DECLARE_FINAL_TYPE(FakeResponseHandle,
fake_response_handle,
FAKE,
RESPONSE_HANDLE,
FlBinaryMessengerResponseHandle)
struct _FakeResponseHandle {
FlBinaryMessengerResponseHandle parent_instance;
GTask* task;
};
G_DEFINE_TYPE(FakeResponseHandle,
fake_response_handle,
fl_binary_messenger_response_handle_get_type())
static void fake_response_handle_dispose(GObject* object) {
FakeResponseHandle* self = FAKE_RESPONSE_HANDLE(object);
if (self->task != nullptr) {
g_task_return_new_error(self->task, G_IO_ERROR, G_IO_ERROR_FAILED,
"no response");
g_clear_object(&self->task);
}
G_OBJECT_CLASS(fake_response_handle_parent_class)->dispose(object);
}
static void fake_response_handle_class_init(FakeResponseHandleClass* klass) {
G_OBJECT_CLASS(klass)->dispose = fake_response_handle_dispose;
}
static void fake_response_handle_init(FakeResponseHandle* self) {}
G_DECLARE_FINAL_TYPE(FakeMessenger, fake_messenger, FAKE, MESSENGER, GObject)
struct Handler {
FlBinaryMessengerMessageHandler handler;
gpointer user_data;
GDestroyNotify destroy_notify;
};
static void handler_free(gpointer data) {
Handler* h = static_cast<Handler*>(data);
if (h->destroy_notify != nullptr) {
h->destroy_notify(h->user_data);
}
g_free(h);
}
struct _FakeMessenger {
GObject parent_instance;
GHashTable* handlers; // channel -> Handler*
FakeMessenger* peer; // not owned
};
static void fake_messenger_iface_init(FlBinaryMessengerInterface* iface);
G_DEFINE_TYPE_WITH_CODE(FakeMessenger,
fake_messenger,
G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE(fl_binary_messenger_get_type(),
fake_messenger_iface_init))
static void fm_set_handler(FlBinaryMessenger* messenger,
const gchar* channel,
FlBinaryMessengerMessageHandler handler,
gpointer user_data,
GDestroyNotify destroy_notify) {
FakeMessenger* self = FAKE_MESSENGER(messenger);
if (handler == nullptr) {
g_hash_table_remove(self->handlers, channel);
return;
}
Handler* h = g_new0(Handler, 1);
h->handler = handler;
h->user_data = user_data;
h->destroy_notify = destroy_notify;
g_hash_table_insert(self->handlers, g_strdup(channel), h);
}
static gboolean fm_send_response(FlBinaryMessenger* messenger,
FlBinaryMessengerResponseHandle* handle,
GBytes* response,
GError** error) {
FakeResponseHandle* h = FAKE_RESPONSE_HANDLE(handle);
if (h->task == nullptr) {
g_set_error(error, G_IO_ERROR, G_IO_ERROR_FAILED, "already responded");
return FALSE;
}
g_task_return_pointer(h->task, g_bytes_ref(response),
reinterpret_cast<GDestroyNotify>(g_bytes_unref));
g_clear_object(&h->task);
return TRUE;
}
static void fm_send_on_channel(FlBinaryMessenger* messenger,
const gchar* channel,
GBytes* message,
GCancellable* cancellable,
GAsyncReadyCallback callback,
gpointer user_data) {
FakeMessenger* self = FAKE_MESSENGER(messenger);
// As in FlBinaryMessengerImpl, the reference from g_task_new belongs to
// send_on_channel_finish; the response handle holds its own.
GTask* task = g_task_new(self, cancellable, callback, user_data);
Handler* h = self->peer == nullptr
? nullptr
: static_cast<Handler*>(
g_hash_table_lookup(self->peer->handlers, channel));
if (h == nullptr) {
g_task_return_new_error(task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"no handler on %s", channel);
return;
}
FakeResponseHandle* handle = FAKE_RESPONSE_HANDLE(
g_object_new(fake_response_handle_get_type(), nullptr));
handle->task = G_TASK(g_object_ref(task));
h->handler(FL_BINARY_MESSENGER(self->peer), channel, message,
FL_BINARY_MESSENGER_RESPONSE_HANDLE(handle), h->user_data);
g_object_unref(handle);
}
static GBytes* fm_send_on_channel_finish(FlBinaryMessenger* messenger,
GAsyncResult* result,
GError** error) {
g_autoptr(GTask) task = G_TASK(result);
return static_cast<GBytes*>(g_task_propagate_pointer(task, error));
}
static void fm_resize_channel(FlBinaryMessenger* messenger,
const gchar* channel,
int64_t new_size) {}
static void fm_set_warns(FlBinaryMessenger* messenger,
const gchar* channel,
bool warns) {}
static void fm_shutdown(FlBinaryMessenger* messenger) {
g_hash_table_remove_all(FAKE_MESSENGER(messenger)->handlers);
}
static void fake_messenger_iface_init(FlBinaryMessengerInterface* iface) {
iface->set_message_handler_on_channel = fm_set_handler;
iface->send_response = fm_send_response;
iface->send_on_channel = fm_send_on_channel;
iface->send_on_channel_finish = fm_send_on_channel_finish;
iface->resize_channel = fm_resize_channel;
iface->set_warns_on_channel_overflow = fm_set_warns;
iface->shutdown = fm_shutdown;
}
static void fake_messenger_dispose(GObject* object) {
FakeMessenger* self = FAKE_MESSENGER(object);
g_clear_pointer(&self->handlers, g_hash_table_unref);
G_OBJECT_CLASS(fake_messenger_parent_class)->dispose(object);
}
static void fake_messenger_class_init(FakeMessengerClass* klass) {
G_OBJECT_CLASS(klass)->dispose = fake_messenger_dispose;
}
static void fake_messenger_init(FakeMessenger* self) {
self->handlers =
g_hash_table_new_full(g_str_hash, g_str_equal, g_free, handler_free);
}
// ---------------------------------------------------------------------------
// Fake plugin registrar.
G_DECLARE_FINAL_TYPE(FakePluginRegistrar,
fake_plugin_registrar,
FAKE,
PLUGIN_REGISTRAR,
GObject)
struct _FakePluginRegistrar {
GObject parent_instance;
FlBinaryMessenger* messenger;
FlTextureRegistrar* textures;
};
static void fake_plugin_registrar_iface_init(
FlPluginRegistrarInterface* iface);
G_DEFINE_TYPE_WITH_CODE(
FakePluginRegistrar,
fake_plugin_registrar,
G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE(fl_plugin_registrar_get_type(),
fake_plugin_registrar_iface_init))
static FlBinaryMessenger* fpr_get_messenger(FlPluginRegistrar* registrar) {
return FAKE_PLUGIN_REGISTRAR(registrar)->messenger;
}
static FlTextureRegistrar* fpr_get_textures(FlPluginRegistrar* registrar) {
return FAKE_PLUGIN_REGISTRAR(registrar)->textures;
}
static FlView* fpr_get_view(FlPluginRegistrar* registrar) {
return nullptr;
}
static void fake_plugin_registrar_iface_init(
FlPluginRegistrarInterface* iface) {
iface->get_messenger = fpr_get_messenger;
iface->get_texture_registrar = fpr_get_textures;
iface->get_view = fpr_get_view;
}
static void fake_plugin_registrar_dispose(GObject* object) {
FakePluginRegistrar* self = FAKE_PLUGIN_REGISTRAR(object);
g_clear_object(&self->messenger);
g_clear_object(&self->textures);
G_OBJECT_CLASS(fake_plugin_registrar_parent_class)->dispose(object);
}
static void fake_plugin_registrar_class_init(FakePluginRegistrarClass* klass) {
G_OBJECT_CLASS(klass)->dispose = fake_plugin_registrar_dispose;
}
static void fake_plugin_registrar_init(FakePluginRegistrar* self) {}
// ---------------------------------------------------------------------------
// One "engine" (= one Flutter window): the plugin registered on it, plus a Dart
// side channel to call it.
struct Engine {
FakeMessenger* messenger;
FakeTextureRegistrar* textures;
FakePluginRegistrar* registrar;
FakeMessenger* dart;
FlMethodChannel* channel;
};
static Engine* engine_new() {
Engine* e = g_new0(Engine, 1);
e->messenger =
FAKE_MESSENGER(g_object_new(fake_messenger_get_type(), nullptr));
e->textures = FAKE_TEXTURE_REGISTRAR(
g_object_new(fake_texture_registrar_get_type(), nullptr));
e->registrar = FAKE_PLUGIN_REGISTRAR(
g_object_new(fake_plugin_registrar_get_type(), nullptr));
e->registrar->messenger = FL_BINARY_MESSENGER(g_object_ref(e->messenger));
e->registrar->textures = FL_TEXTURE_REGISTRAR(g_object_ref(e->textures));
texture_rgba_renderer_plugin_register_with_registrar(
FL_PLUGIN_REGISTRAR(e->registrar));
e->dart = FAKE_MESSENGER(g_object_new(fake_messenger_get_type(), nullptr));
e->dart->peer = e->messenger;
g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
e->channel = fl_method_channel_new(FL_BINARY_MESSENGER(e->dart),
"texture_rgba_renderer",
FL_METHOD_CODEC(codec));
return e;
}
// What the engine does when its window goes away: the messenger drops its
// handlers (the plugin instance is released with them) and the texture
// registrar drops the textures that are still registered.
static void engine_shutdown(Engine* e) {
fm_shutdown(FL_BINARY_MESSENGER(e->messenger));
fm_shutdown(FL_BINARY_MESSENGER(e->dart));
ftr_shutdown(FL_TEXTURE_REGISTRAR(e->textures));
g_clear_object(&e->channel);
g_clear_object(&e->dart);
g_clear_object(&e->registrar);
g_clear_object(&e->textures);
g_clear_object(&e->messenger);
g_free(e);
}
struct CallResult {
gboolean done;
FlMethodResponse* response;
};
static void call_cb(GObject* object, GAsyncResult* result, gpointer user_data) {
CallResult* r = static_cast<CallResult*>(user_data);
r->response = fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
result, nullptr);
r->done = TRUE;
}
// Calls a plugin method like Dart does. Returns the int or bool result, or
// G_MININT64 when the call failed.
static int64_t invoke(Engine* e, const char* method, FlValue* args) {
CallResult r = {FALSE, nullptr};
fl_method_channel_invoke_method(e->channel, method, args, nullptr, call_cb,
&r);
fl_value_unref(args);
for (int i = 0; i < 10000 && !r.done; i++) {
g_main_context_iteration(nullptr, FALSE);
}
int64_t out = G_MININT64;
if (r.response != nullptr) {
FlValue* value = fl_method_response_get_result(r.response, nullptr);
if (value != nullptr && fl_value_get_type(value) == FL_VALUE_TYPE_INT) {
out = fl_value_get_int(value);
} else if (value != nullptr &&
fl_value_get_type(value) == FL_VALUE_TYPE_BOOL) {
out = fl_value_get_bool(value) ? 1 : 0;
}
g_object_unref(r.response);
}
return out;
}
static FlValue* key_args(int64_t key) {
FlValue* args = fl_value_new_map();
fl_value_set_string_take(args, "key", fl_value_new_int(key));
return args;
}
static int64_t create_texture(Engine* e, int64_t key) {
return invoke(e, "createTexture", key_args(key));
}
static int64_t texture_ptr(Engine* e, int64_t key) {
return invoke(e, "getTexturePtr", key_args(key));
}
// recycle < 0: no "recycle" argument (callers before the Kitedesk change).
static int64_t close_texture(Engine* e, int64_t key, int recycle) {
FlValue* args = key_args(key);
if (recycle >= 0) {
fl_value_set_string_take(args, "recycle", fl_value_new_bool(recycle != 0));
}
return invoke(e, "closeTexture", args);
}
// A decoded frame from the Rust video thread (FlutterRgbaRendererPluginOnRgba).
static void send_frame(int64_t ptr, uint8_t fill) {
static uint8_t frames[256][kFrameBytes];
static gboolean filled[256];
if (!filled[fill]) {
memset(frames[fill], fill, kFrameBytes);
filled[fill] = TRUE;
}
FlutterRgbaRendererPluginOnRgba(reinterpret_cast<void*>(ptr), frames[fill],
static_cast<int>(kFrameBytes), kWidth,
kHeight, 0);
}
struct Pulled {
gboolean ok;
const uint8_t* buffer;
uint32_t width;
uint32_t height;
};
// What fl_pixel_buffer_texture_populate asks the texture for on a raster
// frame. width/height start as the canvas size, like in the engine.
static Pulled pull_frame(int64_t ptr) {
Pulled p = {FALSE, nullptr, 999, 777};
FlPixelBufferTexture* texture =
FL_PIXEL_BUFFER_TEXTURE(reinterpret_cast<gpointer>(ptr));
g_autoptr(GError) error = nullptr;
p.ok = FL_PIXEL_BUFFER_TEXTURE_GET_CLASS(texture)->copy_pixels(
texture, &p.buffer, &p.width, &p.height, &error);
return p;
}
static void set_flag(gpointer data, GObject* where_the_object_was) {
*static_cast<gboolean*>(data) = TRUE;
}
// ---------------------------------------------------------------------------
int g_failed_checks = 0;
#define CHECK(cond) \
do { \
if (!(cond)) { \
std::fprintf(stderr, " check failed at line %d: %s\n", __LINE__, \
#cond); \
g_failed_checks++; \
return; \
} \
} while (0)
// D1: closing a texture frees the frame it shows and the frame still waiting
// for the next raster frame.
static void test_close_frees_frame_buffers() {
const int base = live_frames();
Engine* e = engine_new();
int64_t id = create_texture(e, 101);
int64_t ptr = texture_ptr(e, 101);
CHECK(id > 0 && ptr == id);
send_frame(ptr, 1);
Pulled shown = pull_frame(ptr);
CHECK(shown.ok && shown.buffer != nullptr && shown.width == kWidth &&
shown.height == kHeight && shown.buffer[0] == 1);
send_frame(ptr, 2);
CHECK(live_frames() == base + 2);
CHECK(close_texture(e, 101, 0) == 1);
CHECK(live_frames() == base);
engine_shutdown(e);
}
// D1: after close, late frames are dropped and the texture never hands out a
// frame again (it would be a freed buffer).
static void test_closed_texture_ignores_late_frames() {
const int base = live_frames();
Engine* e = engine_new();
int64_t ptr = create_texture(e, 111);
send_frame(ptr, 3);
CHECK(close_texture(e, 111, 0) == 1);
send_frame(ptr, 4);
CHECK(live_frames() == base);
Pulled late = pull_frame(ptr);
CHECK(!late.ok);
engine_shutdown(e);
}
// D1: the GObject frees its frame buffers when it is finalized.
static void test_finalize_frees_frame_buffers() {
const int base = live_frames();
FakeTextureRegistrar* registrar = FAKE_TEXTURE_REGISTRAR(
g_object_new(fake_texture_registrar_get_type(), nullptr));
TextureRgba* texture = texture_rgba_new(FL_TEXTURE_REGISTRAR(registrar));
texture->texture_id = reinterpret_cast<int64_t>(texture);
int64_t ptr = reinterpret_cast<int64_t>(texture);
send_frame(ptr, 5);
CHECK(pull_frame(ptr).ok);
send_frame(ptr, 6);
CHECK(live_frames() == base + 2);
gboolean finalized = FALSE;
g_object_weak_ref(G_OBJECT(texture), set_flag, &finalized);
g_object_unref(texture);
CHECK(finalized);
CHECK(live_frames() == base);
g_object_unref(registrar);
}
// D2: a texture closed with recycle=true is the one the next createTexture of
// the same window gets back, so the engine's GL texture is reused instead of
// left behind; the object is never released (its GL name belongs to that
// window's context).
static void test_recycled_texture_is_reused_in_same_window() {
const int base = live_frames();
Engine* e = engine_new();
std::set<int64_t> seen;
gboolean finalized = FALSE;
for (int i = 0; i < 5; i++) {
int64_t key = 200 + i;
int64_t ptr = create_texture(e, key);
CHECK(ptr > 0 && texture_ptr(e, key) == ptr);
CHECK(registered(e->textures, ptr));
if (seen.empty()) {
g_object_weak_ref(G_OBJECT(reinterpret_cast<gpointer>(ptr)), set_flag,
&finalized);
}
seen.insert(ptr);
send_frame(ptr, 7);
CHECK(pull_frame(ptr).ok);
send_frame(ptr, 8);
CHECK(close_texture(e, key, 1) == 1);
CHECK(!registered(e->textures, ptr));
CHECK(live_frames() == base);
}
CHECK(seen.size() == 1);
CHECK(!finalized);
engine_shutdown(e);
}
// D2, multi-window: windows never get each other's textures back.
static void test_recycling_stays_in_one_window() {
Engine* w1 = engine_new();
Engine* w2 = engine_new();
int64_t a = create_texture(w1, 300);
CHECK(close_texture(w1, 300, 1) == 1);
int64_t b = create_texture(w2, 301);
CHECK(b > 0 && b != a);
CHECK(!registered(w2->textures, a) && !registered(w1->textures, a));
CHECK(close_texture(w2, 301, 1) == 1);
int64_t c = create_texture(w1, 302);
CHECK(c == a && registered(w1->textures, a));
int64_t d = create_texture(w1, 303);
CHECK(d != b && d != a && registered(w1->textures, d));
CHECK(!registered(w1->textures, b));
int64_t f = create_texture(w2, 304);
CHECK(f == b && registered(w2->textures, b));
engine_shutdown(w1);
engine_shutdown(w2);
}
// D2: without recycle (old callers, or a tab moving to another window while
// its session keeps the texture pointer), the texture is never handed out
// again and stays a valid, inert object.
static void test_close_without_recycle_never_reuses() {
const int base = live_frames();
Engine* e = engine_new();
int64_t a = create_texture(e, 400);
gboolean finalized = FALSE;
g_object_weak_ref(G_OBJECT(reinterpret_cast<gpointer>(a)), set_flag,
&finalized);
CHECK(close_texture(e, 400, -1) == 1);
int64_t b = create_texture(e, 401);
CHECK(b > 0 && b != a);
send_frame(a, 9);
CHECK(live_frames() == base);
CHECK(!pull_frame(a).ok);
CHECK(close_texture(e, 401, 0) == 1);
int64_t c = create_texture(e, 402);
CHECK(c != a && c != b);
CHECK(!finalized);
engine_shutdown(e);
}
// D2: a reused texture must not show the last frame of its previous session
// before the new session's first frame. While no frame is waiting the texture
// uploads one transparent pixel instead of leaving the old content.
static void test_reused_texture_shows_no_stale_frame() {
Engine* e = engine_new();
int64_t a = create_texture(e, 500);
send_frame(a, 0xAB);
CHECK(pull_frame(a).ok);
CHECK(close_texture(e, 500, 1) == 1);
int64_t b = create_texture(e, 501);
CHECK(b == a);
Pulled first = pull_frame(b);
CHECK(first.ok && first.buffer != nullptr && first.width == 1 &&
first.height == 1);
CHECK(first.buffer[0] == 0 && first.buffer[1] == 0 && first.buffer[2] == 0 &&
first.buffer[3] == 0);
send_frame(b, 0xCD);
Pulled next = pull_frame(b);
CHECK(next.ok && next.width == kWidth && next.height == kHeight &&
next.buffer[0] == 0xCD);
CHECK(close_texture(e, 501, 1) == 1);
engine_shutdown(e);
}
// D2: when a window's engine goes away the recycled textures are kept alive:
// releasing them would make the engine delete their GL texture in whatever GL
// context is current (another window's), which is the upstream PR #2 defect.
static void test_engine_shutdown_keeps_recycled_textures() {
Engine* e = engine_new();
int64_t a = create_texture(e, 600);
int64_t b = create_texture(e, 601);
gboolean a_finalized = FALSE;
gboolean b_finalized = FALSE;
g_object_weak_ref(G_OBJECT(reinterpret_cast<gpointer>(a)), set_flag,
&a_finalized);
g_object_weak_ref(G_OBJECT(reinterpret_cast<gpointer>(b)), set_flag,
&b_finalized);
CHECK(close_texture(e, 600, 1) == 1);
engine_shutdown(e);
CHECK(!a_finalized && !b_finalized);
}
// D1: frames keep arriving from the video thread while the window closes the
// texture (no recycle: the native side may still hold the pointer).
static void test_frames_racing_close() {
const int base = live_frames();
Engine* e = engine_new();
int64_t ptr = create_texture(e, 700);
std::atomic<bool> stop{false};
std::thread video([ptr, &stop]() {
for (int i = 0; i < 200000 && !stop.load(); i++) {
send_frame(ptr, static_cast<uint8_t>(10 + i % 2));
}
});
for (int i = 0; i < 200; i++) {
pull_frame(ptr);
g_usleep(50);
}
int64_t closed = close_texture(e, 700, 0);
for (int i = 0; i < 200; i++) {
pull_frame(ptr);
g_usleep(50);
}
stop = true;
video.join();
CHECK(closed == 1);
CHECK(live_frames() == base);
engine_shutdown(e);
}
// D2, multi-monitor tab: textures of several displays in one window are
// recycled among themselves without touching the ones still on screen.
static void test_multi_display_tab() {
const int base = live_frames();
Engine* e = engine_new();
int64_t d0 = create_texture(e, 800);
int64_t d1 = create_texture(e, 801);
CHECK(d0 != d1);
send_frame(d0, 20);
CHECK(pull_frame(d0).ok);
send_frame(d1, 21);
CHECK(pull_frame(d1).ok);
// Show display 0 only.
CHECK(close_texture(e, 801, 1) == 1);
send_frame(d0, 22);
Pulled p0 = pull_frame(d0);
CHECK(p0.ok && p0.buffer[0] == 22 && registered(e->textures, d0));
// All displays again.
int64_t d1b = create_texture(e, 802);
CHECK(d1b == d1 && registered(e->textures, d1));
send_frame(d1b, 23);
Pulled p1 = pull_frame(d1b);
CHECK(p1.ok && p1.buffer[0] == 23);
// Close the tab, open another one with two displays.
CHECK(close_texture(e, 800, 1) == 1);
CHECK(close_texture(e, 802, 1) == 1);
CHECK(live_frames() == base);
int64_t n0 = create_texture(e, 803);
int64_t n1 = create_texture(e, 804);
CHECK(std::set<int64_t>({n0, n1}) == std::set<int64_t>({d0, d1}));
CHECK(close_texture(e, 803, 1) == 1);
CHECK(close_texture(e, 804, 1) == 1);
engine_shutdown(e);
}
int main() {
struct {
const char* name;
void (*run)();
} tests[] = {
{"close_frees_frame_buffers", test_close_frees_frame_buffers},
{"closed_texture_ignores_late_frames",
test_closed_texture_ignores_late_frames},
{"finalize_frees_frame_buffers", test_finalize_frees_frame_buffers},
{"recycled_texture_is_reused_in_same_window",
test_recycled_texture_is_reused_in_same_window},
{"recycling_stays_in_one_window", test_recycling_stays_in_one_window},
{"close_without_recycle_never_reuses",
test_close_without_recycle_never_reuses},
{"reused_texture_shows_no_stale_frame",
test_reused_texture_shows_no_stale_frame},
{"engine_shutdown_keeps_recycled_textures",
test_engine_shutdown_keeps_recycled_textures},
{"frames_racing_close", test_frames_racing_close},
{"multi_display_tab", test_multi_display_tab},
};
int failed = 0;
int count = 0;
for (auto& t : tests) {
int before = g_failed_checks;
t.run();
bool ok = g_failed_checks == before;
std::printf("%s %s\n", ok ? "PASS" : "FAIL", t.name);
std::fflush(stdout);
failed += ok ? 0 : 1;
count++;
}
std::printf("%d tests, %d passed, %d failed\n", count, count - failed, failed);
return failed == 0 ? 0 : 1;
}

View file

@ -1,3 +1,7 @@
// Modified by the Kitedesk fork (2026, B212): closeTexture with
// "recycle": true keeps the texture for the next createTexture of the same
// engine instead of leaking it.
#include "include/texture_rgba_renderer/texture_rgba_renderer_plugin.h" #include "include/texture_rgba_renderer/texture_rgba_renderer_plugin.h"
#include "include/texture_rgba_renderer/texture_rgba_renderer.h" #include "include/texture_rgba_renderer/texture_rgba_renderer.h"
@ -19,6 +23,10 @@ struct _TextureRgbaRendererPlugin
{ {
GObject parent_instance; GObject parent_instance;
FlTextureRegistrar *texture_registrar; FlTextureRegistrar *texture_registrar;
// Textures closed with "recycle": true, for the next createTexture of this
// engine (window). Their engine GL texture belongs to this window's GL
// context, so they are never released and never given to another engine.
GPtrArray *recycled;
}; };
G_DEFINE_TYPE(TextureRgbaRendererPlugin, texture_rgba_renderer_plugin, g_object_get_type()) G_DEFINE_TYPE(TextureRgbaRendererPlugin, texture_rgba_renderer_plugin, g_object_get_type())
@ -42,7 +50,13 @@ static void texture_rgba_renderer_plugin_handle_method_call(
} }
else else
{ {
TextureRgba* texture_rgba = texture_rgba_new(self->texture_registrar); TextureRgba* texture_rgba = nullptr;
if (self->recycled->len > 0) {
texture_rgba = TEXTURE_RGBA(g_ptr_array_remove_index_fast(self->recycled, self->recycled->len - 1));
texture_rgba_restart(texture_rgba);
} else {
texture_rgba = texture_rgba_new(self->texture_registrar);
}
auto texture_id = reinterpret_cast<int64_t>(FL_TEXTURE(texture_rgba)); auto texture_id = reinterpret_cast<int64_t>(FL_TEXTURE(texture_rgba));
texture_rgba->texture_id = texture_id; texture_rgba->texture_id = texture_id;
g_renderer_map.insert(std::make_pair(key, texture_rgba)); g_renderer_map.insert(std::make_pair(key, texture_rgba));
@ -55,11 +69,19 @@ static void texture_rgba_renderer_plugin_handle_method_call(
{ {
auto args = fl_method_call_get_args(method_call); auto args = fl_method_call_get_args(method_call);
int64_t key = fl_value_get_int(fl_value_lookup_string(args, "key")); int64_t key = fl_value_get_int(fl_value_lookup_string(args, "key"));
// The caller sets "recycle" only when nothing can call
// FlutterRgbaRendererPluginOnRgba with this texture any more.
FlValue* recycle = fl_value_lookup_string(args, "recycle");
if (g_renderer_map.find(key) != g_renderer_map.end()) if (g_renderer_map.find(key) != g_renderer_map.end())
{ {
fl_texture_registrar_unregister_texture(self->texture_registrar, FL_TEXTURE(g_renderer_map[key])); TextureRgba* texture_rgba = g_renderer_map[key];
texture_rgba_terminate(g_renderer_map[key]); fl_texture_registrar_unregister_texture(self->texture_registrar, FL_TEXTURE(texture_rgba));
texture_rgba_terminate(texture_rgba);
g_renderer_map.erase(key); g_renderer_map.erase(key);
if (recycle != nullptr && fl_value_get_type(recycle) == FL_VALUE_TYPE_BOOL && fl_value_get_bool(recycle) &&
texture_rgba->texture_registrar == self->texture_registrar) {
g_ptr_array_add(self->recycled, texture_rgba);
}
} }
response = FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true))); response = FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true)));
} }
@ -104,6 +126,11 @@ static void texture_rgba_renderer_plugin_handle_method_call(
static void texture_rgba_renderer_plugin_dispose(GObject *object) static void texture_rgba_renderer_plugin_dispose(GObject *object)
{ {
TextureRgbaRendererPlugin *self = TEXTURE_RGBA_RENDERER_PLUGIN(object);
// The engine is going away. The recycled textures keep their references on
// purpose: releasing one makes the engine delete its GL texture in whatever
// GL context is current, which can belong to another window.
g_clear_pointer(&self->recycled, g_ptr_array_unref);
G_OBJECT_CLASS(texture_rgba_renderer_plugin_parent_class)->dispose(object); G_OBJECT_CLASS(texture_rgba_renderer_plugin_parent_class)->dispose(object);
} }
@ -112,7 +139,9 @@ static void texture_rgba_renderer_plugin_class_init(TextureRgbaRendererPluginCla
G_OBJECT_CLASS(klass)->dispose = texture_rgba_renderer_plugin_dispose; G_OBJECT_CLASS(klass)->dispose = texture_rgba_renderer_plugin_dispose;
} }
static void texture_rgba_renderer_plugin_init(TextureRgbaRendererPlugin *self) {} static void texture_rgba_renderer_plugin_init(TextureRgbaRendererPlugin *self) {
self->recycled = g_ptr_array_new();
}
static void method_call_cb(FlMethodChannel *channel, FlMethodCall *method_call, static void method_call_cb(FlMethodChannel *channel, FlMethodCall *method_call,
gpointer user_data) gpointer user_data)

View file

@ -4,6 +4,13 @@
// //
// Created by kingtous on 2023/2/17. // 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 Foundation
import FlutterMacOS import FlutterMacOS
@ -11,11 +18,19 @@ import CoreVideo
@objc public class TextRgba: NSObject, FlutterTexture { @objc public class TextRgba: NSObject, FlutterTexture {
public var textureId: Int64 = -1 public var textureId: Int64 = -1
// Main thread only. Nil once closed.
private var registry: FlutterTextureRegistry? private var registry: FlutterTextureRegistry?
private var data: CVPixelBuffer? private var data: CVPixelBuffer?
private var width: Int = 0 private var width: Int = 0
private var height: Int = 0 private var height: Int = 0
private let queue = DispatchQueue(label: "text_rgba_sync_queue") 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 { public static func new(registry: FlutterTextureRegistry?) -> TextRgba {
let textRgba = TextRgba() let textRgba = TextRgba()
@ -29,46 +44,106 @@ import CoreVideo
if (data == nil) { if (data == nil) {
return nil return nil
} }
if (handed.last !== data) {
handed.append(data!)
if (handed.count > TextRgba.handedFramesKept) {
handed.removeFirst()
}
}
return Unmanaged.passRetained(data!) return Unmanaged.passRetained(data!)
} }
} }
private func _markFrameAvaliable(buffer: UnsafePointer<UInt8>, len: Int, width: Int, height: Int, stride_align: Int) -> Bool { 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? var pixelBufferCopy: CVPixelBuffer?
// macOS only support 32BGRA currently. guard let pool = poolOf(width: width, height: height),
let dict: [String: Any] = [ CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pool, &pixelBufferCopy) == kCVReturnSuccess else {
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
kCVPixelBufferMetalCompatibilityKey as String: true,
kCVPixelBufferOpenGLCompatibilityKey as String: true,
// https://developer.apple.com/forums/thread/712709
kCVPixelBufferBytesPerRowAlignmentKey as String: 64
]
let result = CVPixelBufferCreate(kCFAllocatorDefault, width, height, kCVPixelFormatType_32BGRA, dict as CFDictionary, &pixelBufferCopy)
guard result == kCVReturnSuccess else {
return false return false
} }
// Outside the queue: the raster thread waits on it for the newest frame.
CVPixelBufferLockBaseAddress(pixelBufferCopy!, []) CVPixelBufferLockBaseAddress(pixelBufferCopy!, [])
let ptr = CVPixelBufferGetBaseAddress(pixelBufferCopy!)! let ptr = CVPixelBufferGetBaseAddress(pixelBufferCopy!)!
memcpy(ptr, buffer, len) 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!, []) CVPixelBufferUnlockBaseAddress(pixelBufferCopy!, [])
let open = queue.sync { () -> Bool in
if (closed) {
return false
}
self.data = pixelBufferCopy self.data = pixelBufferCopy
self.width = width return true
self.height = height }
if textureId != -1 && self.data != nil { if open && textureId != -1 {
registry?.textureFrameAvailable(textureId) // On the platform (main) thread, which the engine checks.
DispatchQueue.main.async {
self.registry?.textureFrameAvailable(self.textureId)
}
return true return true
} else { } else {
return false return false
} }
} }
@objc public func markFrameAvaliableRaw(buffer: UnsafePointer<UInt8>, len: Int, width: Int, height: Int, stride_align: Int) -> Bool { // 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 { queue.sync {
_markFrameAvaliable(buffer: buffer, len: len, width: width, height: height, stride_align: stride_align) 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 { @objc public func markFrameAvaliable(data: Data, width: Int, height: Int, stride_align: Int) -> Bool {
data.withUnsafeBytes { buffer in data.withUnsafeBytes { buffer in

View file

@ -4,6 +4,9 @@
// //
// Created by kingtous on 2023/2/19. // Created by kingtous on 2023/2/19.
// //
// Modified by the Kitedesk fork (2026, T-4204): an autorelease pool around
// each frame.
//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import "texture_rgba_renderer/texture_rgba_renderer-Swift.h" #import "texture_rgba_renderer/texture_rgba_renderer-Swift.h"
@ -14,9 +17,13 @@ extern "C" {
/// Keep the same name with Windows. /// Keep the same name with Windows.
void FlutterRgbaRendererPluginOnRgba(void* texture_rgba_ptr, const uint8_t* buffer, int len, int width, int height, int stride_align) { void FlutterRgbaRendererPluginOnRgba(void* texture_rgba_ptr, const uint8_t* buffer, int len, int width, int height, int stride_align) {
// The caller's thread, a session's video thread, has no autorelease pool and
// lives as long as the session.
@autoreleasepool {
TextRgba* texture_rgba = (__bridge TextRgba *)(texture_rgba_ptr); TextRgba* texture_rgba = (__bridge TextRgba *)(texture_rgba_ptr);
[texture_rgba markFrameAvaliableRawWithBuffer:buffer len:len width:width height:height stride_align: stride_align]; [texture_rgba markFrameAvaliableRawWithBuffer:buffer len:len width:width height:height stride_align: stride_align];
} }
}
#if __cplusplus #if __cplusplus
} //Extern C } //Extern C

View file

@ -1,3 +1,7 @@
// Modified by the Kitedesk fork (2026, T-4204): closeTexture lets the
// texture's buffers go, and keeps the closed texture for good unless "recycle"
// is set; the textures of an engine going away are kept the same way.
import Cocoa import Cocoa
import FlutterMacOS import FlutterMacOS
@ -5,6 +9,12 @@ public class TextureRgbaRendererPlugin: NSObject, FlutterPlugin {
private var renderer: Dictionary<Int64, TextRgba> = [:] private var renderer: Dictionary<Int64, TextRgba> = [:]
private var texture_registry: FlutterTextureRegistry? private var texture_registry: FlutterTextureRegistry?
// Textures closed while frames may still be pushed to their pointer from getTexturePtr:
// closeTexture without "recycle" (a tab moving to another window keeps its session's
// pointer), or an engine going away first. They are never freed, so such a frame finds a
// closed texture, not freed memory, and their address is never another texture's (ABA).
// Each keeps the object, not its buffers. Main thread only.
private static var retired: [TextRgba] = []
public static func register(with registrar: FlutterPluginRegistrar) { public static func register(with registrar: FlutterPluginRegistrar) {
let channel = FlutterMethodChannel(name: "texture_rgba_renderer", binaryMessenger: registrar.messenger) let channel = FlutterMethodChannel(name: "texture_rgba_renderer", binaryMessenger: registrar.messenger)
@ -13,6 +23,14 @@ public class TextureRgbaRendererPlugin: NSObject, FlutterPlugin {
registrar.addMethodCallDelegate(instance, channel: channel) registrar.addMethodCallDelegate(instance, channel: channel)
} }
deinit {
// The engine is going away, and sessions may still push frames to these textures.
for textRgba in renderer.values {
textRgba.close()
TextureRgbaRendererPlugin.retired.append(textRgba)
}
}
public func setTextureRegistry(registry: FlutterTextureRegistry) { public func setTextureRegistry(registry: FlutterTextureRegistry) {
texture_registry = registry texture_registry = registry
} }
@ -34,9 +52,15 @@ public class TextureRgbaRendererPlugin: NSObject, FlutterPlugin {
case "closeTexture": case "closeTexture":
let args = call.arguments as! Dictionary<String, Any?> let args = call.arguments as! Dictionary<String, Any?>
let key = args["key"] as! Int64 let key = args["key"] as! Int64
if (renderer[key] != nil) { // "recycle": true promises that nothing pushes frames to the pointer any more.
if (-1 != renderer[key]?.textureId) { let recycle = args["recycle"] as? Bool ?? false
texture_registry?.unregisterTexture(renderer[key]?.textureId ?? -1) if let textRgba = renderer.removeValue(forKey: key) {
textRgba.close()
if (-1 != textRgba.textureId) {
texture_registry?.unregisterTexture(textRgba.textureId)
}
if (!recycle) {
TextureRgbaRendererPlugin.retired.append(textRgba)
} }
result(true) result(true)
} else { } else {

65
macos/test/run_tests.sh Executable file
View file

@ -0,0 +1,65 @@
#!/usr/bin/env bash
# Kitedesk fork, 2026: builds macos/test/texture_rgba_renderer_plugin_test.m with
# the plugin sources of macos/Classes against FlutterMacOS.framework, by default
# the darwin-x64 engine artifacts of the Flutter SDK on PATH (or FLUTTER_ROOT) as
# `flutter precache --macos` leaves them, and runs each test in its own process.
# Swift 5 mode, as the podspec. No app, window or screen capture; Metal is used
# without a display.
# run_tests.sh plain build
# run_tests.sh --asan the same with AddressSanitizer
# run_tests.sh --tsan the same with ThreadSanitizer
# FLUTTER_MACOS_FRAMEWORKS: the directory holding FlutterMacOS.framework.
# OUT_DIR (default: a new temporary directory) receives the build.
set -euo pipefail
here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
classes=$here/../Classes
if [ -z "${FLUTTER_MACOS_FRAMEWORKS:-}" ]; then
root=${FLUTTER_ROOT:-$(dirname "$(dirname "$(readlink -f "$(command -v flutter)")")")}
FLUTTER_MACOS_FRAMEWORKS=$root/bin/cache/artifacts/engine/darwin-x64/FlutterMacOS.xcframework/macos-arm64_x86_64
fi
frameworks=$FLUTTER_MACOS_FRAMEWORKS
[ -f "$frameworks/FlutterMacOS.framework/Headers/FlutterTexture.h" ] || {
echo "no FlutterMacOS.framework in $frameworks" \
"(flutter precache --macos, or set FLUTTER_MACOS_FRAMEWORKS)" >&2
exit 2
}
out=${OUT_DIR:-$(mktemp -d)}
mkdir -p "$out/include/texture_rgba_renderer"
sanitizer=()
case "${1:-}" in
"") ;;
--asan) sanitizer=(-sanitize=address) ;;
--tsan)
sanitizer=(-sanitize=thread)
export TSAN_OPTIONS=${TSAN_OPTIONS:-halt_on_error=1}
;;
*) echo "usage: $0 [--asan | --tsan]" >&2; exit 2 ;;
esac
clang_sanitizer=()
[ ${#sanitizer[@]} -eq 0 ] || clang_sanitizer=("-f${sanitizer[0]#-}" -fno-omit-frame-pointer)
cache=$out/module-cache
xcrun swiftc -c -wmo -g -O -swift-version 5 -parse-as-library -module-name texture_rgba_renderer \
${sanitizer[@]+"${sanitizer[@]}"} -F "$frameworks" -module-cache-path "$cache" \
-emit-objc-header-path "$out/include/texture_rgba_renderer/texture_rgba_renderer-Swift.h" \
"$classes"/*.swift -o "$out/plugin.o"
objc=(xcrun clang -c -g -O1 -fobjc-arc -fmodules -fmodules-cache-path="$cache"
${clang_sanitizer[@]+"${clang_sanitizer[@]}"} -F "$frameworks" -I "$out/include")
"${objc[@]}" "$classes/TextureRgbaApi.m" -o "$out/api.o"
"${objc[@]}" -Wall -Werror "$here/texture_rgba_renderer_plugin_test.m" -o "$out/test.o"
bin=$out/texture_rgba_renderer_plugin_test
xcrun swiftc ${sanitizer[@]+"${sanitizer[@]}"} -F "$frameworks" -framework FlutterMacOS \
-framework CoreVideo -framework IOSurface -framework Metal -Xlinker -rpath -Xlinker "$frameworks" \
"$out/plugin.o" "$out/api.o" "$out/test.o" -o "$bin"
count=0
failed=0
for test in $("$bin" --list); do
count=$((count + 1))
if "$bin" "$test"; then
echo "PASS $test"
else
echo "FAIL $test"
failed=$((failed + 1))
fi
done
echo "$count tests, $((count - failed)) passed, $failed failed"
[ "$failed" -eq 0 ]

View file

@ -0,0 +1,750 @@
// Kitedesk fork, 2026: tests for the macOS texture of this plugin (Kitedesk
// backlog T-4204). Licensed under the Apache License, Version 2.0, like the rest
// of this package.
//
// macos/test/run_tests.sh builds this program with the plugin sources against
// FlutterMacOS.framework of the Flutter engine (a18df97c, Flutter 3.24.5) and
// runs each test in its own process. Nothing is drawn on screen: the engine is
// the fake below. It follows FlutterTextureRegistrar.mm and
// FlutterExternalTexture.mm of that engine: the registrar keeps a registered
// texture until it is unregistered and uses its address as the texture id; for
// a new frame the raster thread calls copyPixelBuffer, makes a Metal texture of
// the pixel buffer with a CVMetalTextureCache and releases the CVMetalTexture and
// the pixel buffer right away, while Skia goes on drawing that Metal texture
// until the next frame. textureFrameAvailable: belongs on the platform (main)
// thread (Shell::OnPlatformViewMarkTextureFrameAvailable checks it). When a
// window closes, its engine, registrar and plugins go away. The Rust video
// thread is FlutterRgbaRendererPluginOnRgba with the pointer from getTexturePtr,
// on a thread of its own without an autorelease pool.
//
// Usage: texture_rgba_renderer_plugin_test [--list | <test>]
#import <CoreVideo/CoreVideo.h>
#import <FlutterMacOS/FlutterMacOS.h>
#import <Foundation/Foundation.h>
#import <IOSurface/IOSurface.h>
#import <Metal/Metal.h>
#include <fcntl.h>
#include <mach/mach.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
// The generated header declares copyPixelBuffer's CVPixelBufferRef __unsafe_unretained.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wignored-attributes"
#import "texture_rgba_renderer/texture_rgba_renderer-Swift.h"
#pragma clang diagnostic pop
void FlutterRgbaRendererPluginOnRgba(void* texture_rgba_ptr, const uint8_t* buffer, int len, int width,
int height, int stride_align);
#if defined(__has_feature)
#if __has_feature(address_sanitizer)
#define KD_ASAN 1
#endif
#endif
static int failures = 0;
#define EXPECT(condition, ...) \
do { \
if (!(condition)) { \
failures++; \
fprintf(stderr, "%s:%d: expected %s: ", __FILE__, __LINE__, #condition); \
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
} \
} while (0)
// textureFrameAvailable: calls, and those not on the main thread.
static atomic_int notices = 0;
static atomic_int off_main_notices = 0;
static uint64_t now_ns(void) { return clock_gettime_nsec_np(CLOCK_UPTIME_RAW); }
// Memory of the process, IOSurfaces included (what Activity Monitor shows).
static double footprint_mb(void) {
task_vm_info_data_t info;
mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
if (task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&info, &count) != KERN_SUCCESS) {
return 0;
}
return info.phys_footprint / 1048576.0;
}
@interface FakeEngine : NSObject <FlutterTextureRegistry>
// What the raster thread does for a new frame of the texture: the Metal texture
// it draws from now on, or nil when the texture gives no frame.
- (id<MTLTexture>)draw:(int64_t)textureId;
@end
@implementation FakeEngine {
// FlutterTextureRegistrar's textures (FlutterExternalTexture keeps the texture).
NSMutableDictionary<NSNumber*, NSObject<FlutterTexture>*>* _textures;
// Skia's last image of each texture.
NSMutableDictionary<NSNumber*, id<MTLTexture>>* _drawn;
id<MTLDevice> _device;
CVMetalTextureCacheRef _cache;
}
- (instancetype)init {
if (self = [super init]) {
_textures = [NSMutableDictionary dictionary];
_drawn = [NSMutableDictionary dictionary];
_device = MTLCreateSystemDefaultDevice();
CVMetalTextureCacheCreate(kCFAllocatorDefault, NULL, _device, NULL, &_cache);
}
return self;
}
- (void)dealloc {
if (_cache) {
CFRelease(_cache);
}
}
- (int64_t)registerTexture:(NSObject<FlutterTexture>*)texture {
int64_t textureId = (int64_t)(intptr_t)(__bridge void*)texture;
_textures[@(textureId)] = texture;
return textureId;
}
- (void)textureFrameAvailable:(int64_t)textureId {
atomic_fetch_add(&notices, 1);
if (![NSThread isMainThread]) {
atomic_fetch_add(&off_main_notices, 1);
}
}
- (void)unregisterTexture:(int64_t)textureId {
[_textures removeObjectForKey:@(textureId)];
[_drawn removeObjectForKey:@(textureId)];
}
- (id<MTLTexture>)draw:(int64_t)textureId {
CVPixelBufferRef pixelBuffer = [_textures[@(textureId)] copyPixelBuffer];
id<MTLTexture> drawn = nil;
if (pixelBuffer) {
CVMetalTextureRef cvMetalTexture = NULL;
CVMetalTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _cache, pixelBuffer, NULL,
MTLPixelFormatBGRA8Unorm, CVPixelBufferGetWidth(pixelBuffer),
CVPixelBufferGetHeight(pixelBuffer), 0, &cvMetalTexture);
if (cvMetalTexture) {
drawn = CVMetalTextureGetTexture(cvMetalTexture);
CFRelease(cvMetalTexture);
}
CVPixelBufferRelease(pixelBuffer);
}
if (drawn) {
_drawn[@(textureId)] = drawn;
} else {
[_drawn removeObjectForKey:@(textureId)];
}
return drawn;
}
@end
// Plugins only make their channel with the engine's binary messenger here.
@interface FakeMessenger : NSObject <FlutterBinaryMessenger>
@end
@implementation FakeMessenger
- (void)sendOnChannel:(NSString*)channel message:(NSData*)message {
}
- (void)sendOnChannel:(NSString*)channel message:(NSData*)message binaryReply:(FlutterBinaryReply)callback {
}
- (FlutterBinaryMessengerConnection)setMessageHandlerOnChannel:(NSString*)channel
binaryMessageHandler:(FlutterBinaryMessageHandler)handler {
return 0;
}
- (void)cleanUpConnection:(FlutterBinaryMessengerConnection)connection {
}
@end
// The plugin registrar of one engine (window). It keeps the plugin, as the
// engine's channel handler does, until the engine goes away.
@interface FakeRegistrar : NSObject <FlutterPluginRegistrar>
- (instancetype)initWithEngine:(FakeEngine*)engine;
@property(nonatomic, readonly) NSObject<FlutterPlugin>* plugin;
@end
@implementation FakeRegistrar {
FakeEngine* _engine;
FakeMessenger* _messenger;
}
- (instancetype)initWithEngine:(FakeEngine*)engine {
if (self = [super init]) {
_engine = engine;
_messenger = [FakeMessenger new];
}
return self;
}
- (id<FlutterBinaryMessenger>)messenger {
return _messenger;
}
- (id<FlutterTextureRegistry>)textures {
return _engine;
}
- (NSView*)view {
return nil;
}
- (void)addMethodCallDelegate:(id<FlutterPlugin>)delegate channel:(FlutterMethodChannel*)channel {
_plugin = delegate;
}
- (void)addApplicationDelegate:(NSObject<FlutterAppLifecycleDelegate>*)delegate {
}
- (void)registerViewFactory:(NSObject<FlutterPlatformViewFactory>*)factory withId:(NSString*)factoryId {
}
- (void)publish:(NSObject*)value {
}
- (NSString*)lookupKeyForAsset:(NSString*)asset {
return asset;
}
- (NSString*)lookupKeyForAsset:(NSString*)asset fromPackage:(NSString*)package {
return asset;
}
@end
static id call(TextureRgbaRendererPlugin* plugin, NSString* method, NSDictionary* arguments) {
__block id answer = nil;
__block BOOL answered = NO;
[plugin handleMethodCall:[FlutterMethodCall methodCallWithMethodName:method arguments:arguments]
result:^(id result) {
answer = result;
answered = YES;
}];
EXPECT(answered, "an answer to %s", method.UTF8String);
return answer;
}
// The plugin, registered as an engine registers it.
static TextureRgbaRendererPlugin* new_plugin(FakeEngine* engine) {
FakeRegistrar* registrar = [[FakeRegistrar alloc] initWithEngine:engine];
[TextureRgbaRendererPlugin registerWithRegistrar:registrar];
EXPECT([registrar.plugin isKindOfClass:[TextureRgbaRendererPlugin class]], "the plugin registered");
return (TextureRgbaRendererPlugin*)registrar.plugin;
}
static int64_t create_texture(TextureRgbaRendererPlugin* plugin, int64_t key) {
return [call(plugin, @"createTexture", @{@"key" : @(key)}) longLongValue];
}
static void* texture_pointer(TextureRgbaRendererPlugin* plugin, int64_t key) {
return (void*)(uintptr_t)[call(plugin, @"getTexturePtr", @{@"key" : @(key)}) unsignedLongValue];
}
static void close_texture(TextureRgbaRendererPlugin* plugin, int64_t key, BOOL recycle) {
call(plugin, @"closeTexture", @{@"key" : @(key), @"recycle" : @(recycle)});
}
// Runs the main queue up to what is queued now, as the platform thread does.
static void drain_main_queue(void) {
__block BOOL done = NO;
dispatch_async(dispatch_get_main_queue(), ^{
done = YES;
});
while (!done) {
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.01, true);
}
}
static void* run_block(void* block) {
((__bridge_transfer void (^)(void))block)();
return NULL;
}
// Runs |block| on a new thread with no autorelease pool, as a Rust video thread.
static pthread_t start_video_thread(void (^block)(void)) {
pthread_t thread;
pthread_create(&thread, NULL, run_block, (__bridge_retained void*)[block copy]);
return thread;
}
static void on_video_thread(void (^block)(void)) { pthread_join(start_video_thread(block), NULL); }
// A frame of |width| x |height| BGRA pixels in rows of |stride| bytes; the
// padding at the end of a row is 0xee.
static NSData* make_frame(int width, int height, int stride, int seed) {
NSMutableData* frame = [NSMutableData dataWithLength:(NSUInteger)stride * height];
uint8_t* bytes = frame.mutableBytes;
memset(bytes, 0xee, frame.length);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width * 4; x++) {
bytes[(size_t)y * stride + x] = (uint8_t)(seed * 31 + y * 7 + x);
}
}
return frame;
}
static void push_bytes(void* pointer, NSData* frame, int length, int width, int height, int stride_align) {
const uint8_t* bytes = frame.bytes;
on_video_thread(^{
FlutterRgbaRendererPluginOnRgba(pointer, bytes, length, width, height, stride_align);
});
}
static void push(void* pointer, NSData* frame, int width, int height, int stride_align) {
push_bytes(pointer, frame, (int)frame.length, width, height, stride_align);
}
// The first row of |surface| that differs from the frame, or -1.
static int first_wrong_row(IOSurfaceRef surface, NSData* frame, int width, int height, int stride) {
if (!surface || (int)IOSurfaceGetWidth(surface) != width || (int)IOSurfaceGetHeight(surface) != height) {
return 0;
}
int wrong = -1;
IOSurfaceLock(surface, kIOSurfaceLockReadOnly, NULL);
const uint8_t* pixels = IOSurfaceGetBaseAddress(surface);
size_t row = IOSurfaceGetBytesPerRow(surface);
for (int y = 0; y < height && wrong < 0; y++) {
if (memcmp(pixels + y * row, (const uint8_t*)frame.bytes + (size_t)y * stride, (size_t)width * 4) != 0) {
wrong = y;
}
}
IOSurfaceUnlock(surface, kIOSurfaceLockReadOnly, NULL);
return wrong;
}
static int compare_u64(const void* a, const void* b) {
uint64_t x = *(const uint64_t*)a, y = *(const uint64_t*)b;
return x < y ? -1 : x > y;
}
// Frames of one size go to a few pooled IOSurfaces, as many whatever the
// number of frames; a new size gets buffers of its own.
static void pool_reuses_buffers(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
static const int sizes[][2] = {{640, 480}, {800, 600}};
for (int s = 0; s < 2; s++) {
int width = sizes[s][0], height = sizes[s][1];
// Kept, so that no IOSurface id is reused for a new IOSurface.
NSMutableArray<id<MTLTexture>>* drawn = [NSMutableArray array];
NSMutableSet<NSNumber*>* surfaces = [NSMutableSet set];
for (int i = 0; i < 60; i++) {
push(pointer, make_frame(width, height, width * 4, i), width, height, 1);
drain_main_queue();
id<MTLTexture> frame = [engine draw:texture];
EXPECT(frame && frame.iosurface && (int)frame.width == width && (int)frame.height == height,
"frame %d of %dx%d drawn from an IOSurface of that size", i, width, height);
if (frame.iosurface) {
[drawn addObject:frame];
[surfaces addObject:@(IOSurfaceGetID(frame.iosurface))];
}
}
EXPECT(surfaces.count <= 4, "%lu IOSurfaces for 60 frames of %dx%d", (unsigned long)surfaces.count, width,
height);
}
}
// The pool does not wait until the engine's GPU work with a buffer is done (it
// hands out a buffer whose IOSurface backs a live Metal texture), and the
// engine lets go of its pixel buffer as soon as it has the Metal texture: the
// buffer the engine draws must not be written while frames come and the engine
// takes none.
static void drawn_frame_is_not_overwritten(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
const int width = 320, height = 240, stride = width * 4;
NSData* first = make_frame(width, height, stride, 1);
push(pointer, first, width, height, 1);
drain_main_queue();
id<MTLTexture> drawn = [engine draw:texture];
NSData* last = nil;
for (int i = 2; i <= 8; i++) {
last = make_frame(width, height, stride, i);
push(pointer, last, width, height, 1);
drain_main_queue();
}
int wrong = first_wrong_row(drawn.iosurface, first, width, height, stride);
EXPECT(wrong < 0, "the frame the engine draws unchanged by newer frames, row %d differs", wrong);
wrong = first_wrong_row([engine draw:texture].iosurface, last, width, height, stride);
EXPECT(wrong < 0, "the newest frame drawn next, row %d differs", wrong);
}
// Nor the frame the engine was handed before that one: GPU work queued while it
// was drawn may not have run yet, and the plugin cannot see when it has.
static void frame_drawn_before_is_not_overwritten(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
const int width = 320, height = 240, stride = width * 4;
NSData* before = make_frame(width, height, stride, 1);
push(pointer, before, width, height, 1);
drain_main_queue();
id<MTLTexture> drawn_before = [engine draw:texture];
NSData* drawn_frame = make_frame(width, height, stride, 2);
push(pointer, drawn_frame, width, height, 1);
drain_main_queue();
id<MTLTexture> drawn = [engine draw:texture];
NSData* last = nil;
for (int i = 3; i <= 9; i++) {
last = make_frame(width, height, stride, i);
push(pointer, last, width, height, 1);
drain_main_queue();
}
int wrong = first_wrong_row(drawn_before.iosurface, before, width, height, stride);
EXPECT(wrong < 0, "the frame drawn before the last one unchanged by newer frames, row %d differs", wrong);
wrong = first_wrong_row(drawn.iosurface, drawn_frame, width, height, stride);
EXPECT(wrong < 0, "the frame the engine draws unchanged by newer frames, row %d differs", wrong);
wrong = first_wrong_row([engine draw:texture].iosurface, last, width, height, stride);
EXPECT(wrong < 0, "the newest frame drawn next, row %d differs", wrong);
}
// The raster thread asks for the newest frame (copyPixelBuffer) while the video
// thread copies 4K frames back to back: it must not wait for a copy.
static void raster_does_not_wait_for_copies(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
TextRgba* texture = (__bridge TextRgba*)pointer;
const int width = 3840, height = 2160;
NSData* frame = make_frame(width, height, width * 4, 1);
const uint8_t* bytes = frame.bytes;
const int length = (int)frame.length;
static atomic_bool stop = false;
static atomic_int pushed = 0;
pthread_t video = start_video_thread(^{
while (!atomic_load(&stop)) {
FlutterRgbaRendererPluginOnRgba(pointer, bytes, length, width, height, 64);
atomic_fetch_add(&pushed, 1);
}
});
enum { kCalls = 600 };
static uint64_t waits[kCalls];
int calls = 0;
for (; calls < kCalls; calls++) {
uint64_t start = now_ns();
CVPixelBufferRef newest = [texture copyPixelBuffer];
waits[calls] = now_ns() - start;
if (newest) {
CVPixelBufferRelease(newest);
}
usleep(1000);
}
atomic_store(&stop, true);
pthread_join(video, NULL);
drain_main_queue();
qsort(waits, calls, sizeof waits[0], compare_u64);
int over_1ms = 0;
for (int i = 0; i < calls; i++) {
over_1ms += waits[i] > 1000000;
}
double p50 = waits[calls / 2] / 1e6, max = waits[calls - 1] / 1e6;
fprintf(stderr, "raster waits: %d calls, %d frames pushed, p50 %.3f ms, max %.3f ms, %d over 1 ms\n", calls,
atomic_load(&pushed), p50, max, over_1ms);
EXPECT(atomic_load(&pushed) > 0, "frames pushed meanwhile");
EXPECT(p50 < 0.25, "a median wait of %.3f ms", p50);
EXPECT(over_1ms * 100 <= calls, "%d of %d calls waited over 1 ms", over_1ms, calls);
}
// textureFrameAvailable: on the main thread, not on the video thread.
static void frames_are_announced_on_the_main_thread(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
push(pointer, make_frame(64, 64, 256, 1), 64, 64, 1);
drain_main_queue();
EXPECT(atomic_load(&notices) == 1, "one notice for one frame, got %d", atomic_load(&notices));
EXPECT(atomic_load(&off_main_notices) == 0, "%d notices off the main thread", atomic_load(&off_main_notices));
}
// The engine's CVMetalTextureCache keeps what it wrapped until it makes a
// texture again about a second later (measured): age that out as the engine
// does when it draws its next frame, so that only what the plugin keeps is left.
static void age_texture_cache(TextureRgbaRendererPlugin* plugin, FakeEngine* engine, int64_t key) {
usleep(1500000);
@autoreleasepool {
int64_t texture = create_texture(plugin, key);
push(texture_pointer(plugin, key), make_frame(64, 64, 256, 1), 64, 64, 1);
drain_main_queue();
[engine draw:texture];
close_texture(plugin, key, YES);
drain_main_queue();
}
}
// Each texture a session opens and closes (a display switch, a tab closing)
// leaves no frame buffer behind, with or without "recycle".
static void closing_frees_frame_buffers(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
const int width = 3840, height = 2160;
NSData* frame = make_frame(width, height, width * 4, 1);
double before = 0;
for (int key = 0; key <= 20; key++) {
@autoreleasepool {
int64_t texture = create_texture(plugin, key);
void* pointer = texture_pointer(plugin, key);
push(pointer, frame, width, height, 64);
drain_main_queue();
[engine draw:texture];
push(pointer, frame, width, height, 64);
drain_main_queue();
close_texture(plugin, key, key % 2 == 0);
drain_main_queue();
}
if (key == 0) {
age_texture_cache(plugin, engine, 100);
before = footprint_mb();
}
}
age_texture_cache(plugin, engine, 101);
double growth = footprint_mb() - before;
fprintf(stderr, "closing: %.1f MB more after 20 more 4K textures were opened and closed\n", growth);
#ifndef KD_ASAN
// ASan keeps shadow memory, an eighth of it, for each new IOSurface mapping
// memcpy writes to, and that counts too (76 MB here, its quarantine off).
EXPECT(growth < 64, "%.1f MB more after 20 more 4K textures were opened and closed (a frame is %.1f MB)",
growth, width * height * 4 / 1048576.0);
#endif
}
// After closeTexture without "recycle" the session may still push frames to the
// pointer for a while: they are dropped, without a notice or a frame for the
// engine, and the texture stays a valid object.
static void closed_texture_drops_late_frames(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
NSData* frame = make_frame(640, 480, 2560, 1);
push(pointer, frame, 640, 480, 64);
drain_main_queue();
[engine draw:texture];
close_texture(plugin, 1, NO);
drain_main_queue();
int before = atomic_load(&notices);
for (int i = 0; i < 5; i++) {
push(pointer, frame, 640, 480, 64);
}
drain_main_queue();
EXPECT(atomic_load(&notices) == before, "%d notices for frames after closing", atomic_load(&notices) - before);
CVPixelBufferRef late = [(__bridge TextRgba*)pointer copyPixelBuffer];
EXPECT(late == NULL, "no frame from a closed texture");
if (late) {
CVPixelBufferRelease(late);
}
}
// Without "recycle" the pointer of a closed texture may still get frames, so the
// texture is never freed; with "recycle" nothing pushes frames to it any more,
// and it goes once the engine has unregistered it.
static void closing_keeps_only_unrecycled_textures(void) {
__weak TextRgba* kept = nil;
__weak TextRgba* recycled = nil;
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
@autoreleasepool {
NSData* frame = make_frame(64, 64, 256, 1);
for (int key = 1; key <= 2; key++) {
int64_t texture = create_texture(plugin, key);
void* pointer = texture_pointer(plugin, key);
push(pointer, frame, 64, 64, 1);
drain_main_queue();
[engine draw:texture];
if (key == 1) {
kept = (__bridge TextRgba*)pointer;
} else {
recycled = (__bridge TextRgba*)pointer;
}
close_texture(plugin, key, key == 2);
drain_main_queue();
}
}
EXPECT(kept != nil, "the texture closed without recycle still there");
EXPECT(recycled == nil, "the texture closed with recycle freed");
}
// A window closing first: its engine and plugin go away while a session may
// still push frames to the pointer of a texture nobody closed.
static void open_textures_outlive_their_engine(void) {
__weak TextRgba* weak = nil;
void* pointer = NULL;
NSData* frame = make_frame(64, 64, 256, 1);
@autoreleasepool {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
pointer = texture_pointer(plugin, 1);
push(pointer, frame, 64, 64, 1);
drain_main_queue();
[engine draw:texture];
weak = (__bridge TextRgba*)pointer;
}
drain_main_queue();
EXPECT(weak != nil, "the texture alive after its engine went away");
if (weak) {
int before = atomic_load(&notices);
push(pointer, frame, 64, 64, 1);
drain_main_queue();
EXPECT(atomic_load(&notices) == before, "no notice for a frame after the engine went away");
}
}
static int round_up(int value, int alignment) {
return alignment > 1 ? (value + alignment - 1) / alignment * alignment : value;
}
// Rows come padded to stride_align (src/flutter.rs rgba_align: 64 for a macOS
// texture, 1 for a session drawn in software, whose "all displays" view still
// uses textures), the pixel buffer has its own bytes per row.
static void rows_follow_the_frame_stride(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
static const int cases[][2] = {{1366, 1}, {1001, 1}, {1279, 1}, {3838, 1},
{1366, 64}, {1001, 64}, {3840, 64}, {1001, 256}};
const int height = 16;
for (int c = 0; c < (int)(sizeof cases / sizeof cases[0]); c++) {
int width = cases[c][0], align = cases[c][1], stride = round_up(width * 4, align);
int64_t texture = create_texture(plugin, c);
void* pointer = texture_pointer(plugin, c);
NSData* frame = make_frame(width, height, stride, c);
push(pointer, frame, width, height, align);
drain_main_queue();
int wrong = first_wrong_row([engine draw:texture].iosurface, frame, width, height, stride);
EXPECT(wrong < 0, "%d pixels wide in rows of %d bytes: row %d differs", width, stride, wrong);
close_texture(plugin, c, YES);
drain_main_queue();
}
}
// A frame shorter than its rows promise is not read past its end.
static void short_frames_are_dropped(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
NSData* frame = make_frame(640, 480, 2560, 1);
push_bytes(pointer, frame, (int)frame.length - 1, 640, 480, 64);
drain_main_queue();
EXPECT(atomic_load(&notices) == 0, "no notice for a short frame");
EXPECT([engine draw:texture] == nil, "no frame for the engine");
}
// The video thread has no autorelease pool: whatever the plugin autoreleases
// there would pile up until the session ends. OBJC_DEBUG_MISSING_POOLS makes the
// runtime report each such object on stderr.
static void frames_leave_no_autoreleased_objects(void) {
EXPECT(getenv("OBJC_DEBUG_MISSING_POOLS") != NULL, "OBJC_DEBUG_MISSING_POOLS set (main sets it)");
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
int64_t texture = create_texture(plugin, 1);
void* pointer = texture_pointer(plugin, 1);
char path[] = "/tmp/texture_rgba_renderer_test.XXXXXX";
int log = mkstemp(path);
int saved = dup(STDERR_FILENO);
fflush(stderr);
dup2(log, STDERR_FILENO);
// New sizes, so that buffers are made, not only reused.
for (int i = 0; i < 3; i++) {
int width = 320 + 64 * i, height = 240;
push(pointer, make_frame(width, height, width * 4, i), width, height, 64);
}
fflush(stderr);
dup2(saved, STDERR_FILENO);
close(saved);
drain_main_queue();
[engine draw:texture];
NSString* reported = [NSString stringWithContentsOfFile:@(path) encoding:NSUTF8StringEncoding error:nil] ?: @"";
close(log);
unlink(path);
NSUInteger objects = [reported componentsSeparatedByString:@"autoreleased with no pool in place"].count - 1;
EXPECT(objects == 0, "%lu objects autoreleased on the video thread:\n%s", (unsigned long)objects,
reported.UTF8String);
}
// Frames pushed while the texture is being closed, for the sanitizers.
static void frames_racing_close(void) {
FakeEngine* engine = [FakeEngine new];
TextureRgbaRendererPlugin* plugin = new_plugin(engine);
const int width = 1920, height = 1080;
NSData* frame = make_frame(width, height, width * 4, 1);
const uint8_t* bytes = frame.bytes;
const int length = (int)frame.length;
for (int key = 0; key < 20; key++) {
@autoreleasepool {
int64_t texture = create_texture(plugin, key);
void* pointer = texture_pointer(plugin, key);
static atomic_bool stop;
atomic_store(&stop, false);
pthread_t video = start_video_thread(^{
while (!atomic_load(&stop)) {
FlutterRgbaRendererPluginOnRgba(pointer, bytes, length, width, height, 64);
}
});
usleep(2000 + key * 300);
[engine draw:texture];
close_texture(plugin, key, NO);
usleep(2000);
atomic_store(&stop, true);
pthread_join(video, NULL);
drain_main_queue();
int before = atomic_load(&notices);
push(pointer, frame, width, height, 64);
drain_main_queue();
EXPECT(atomic_load(&notices) == before, "texture %d: a notice after closing", key);
}
}
}
typedef struct {
const char* name;
void (*run)(void);
} Test;
static const Test kTests[] = {
{"pool_reuses_buffers", pool_reuses_buffers},
{"drawn_frame_is_not_overwritten", drawn_frame_is_not_overwritten},
{"frame_drawn_before_is_not_overwritten", frame_drawn_before_is_not_overwritten},
{"raster_does_not_wait_for_copies", raster_does_not_wait_for_copies},
{"frames_are_announced_on_the_main_thread", frames_are_announced_on_the_main_thread},
{"closing_frees_frame_buffers", closing_frees_frame_buffers},
{"closed_texture_drops_late_frames", closed_texture_drops_late_frames},
{"closing_keeps_only_unrecycled_textures", closing_keeps_only_unrecycled_textures},
{"open_textures_outlive_their_engine", open_textures_outlive_their_engine},
{"rows_follow_the_frame_stride", rows_follow_the_frame_stride},
{"short_frames_are_dropped", short_frames_are_dropped},
{"frames_leave_no_autoreleased_objects", frames_leave_no_autoreleased_objects},
{"frames_racing_close", frames_racing_close},
};
int main(int argc, char** argv) {
if (argc == 2 && strcmp(argv[1], "--list") == 0) {
for (size_t i = 0; i < sizeof kTests / sizeof kTests[0]; i++) {
printf("%s\n", kTests[i].name);
}
return 0;
}
if (argc != 2) {
fprintf(stderr, "usage: %s [--list | <test>]\n", argv[0]);
return 2;
}
// The runtime reads it at startup.
if (strcmp(argv[1], "frames_leave_no_autoreleased_objects") == 0 && !getenv("OBJC_DEBUG_MISSING_POOLS")) {
setenv("OBJC_DEBUG_MISSING_POOLS", "YES", 1);
execv(argv[0], argv);
}
for (size_t i = 0; i < sizeof kTests / sizeof kTests[0]; i++) {
if (strcmp(argv[1], kTests[i].name) == 0) {
@autoreleasepool {
kTests[i].run();
}
return failures == 0 ? 0 : 1;
}
}
fprintf(stderr, "no test %s\n", argv[1]);
return 2;
}

View file

@ -1,3 +1,4 @@
// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`.
import 'package:flutter/services.dart'; import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart'; import 'package:flutter_test/flutter_test.dart';
import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart';
@ -22,4 +23,20 @@ void main() {
test('getPlatformVersion', () async { test('getPlatformVersion', () async {
expect(await platform.getPlatformVersion(), '42'); expect(await platform.getPlatformVersion(), '42');
}); });
// Kitedesk fork (B212): closeTexture tells the Linux side whether the
// texture may be recycled.
test('closeTexture sends recycle', () async {
final calls = <MethodCall>[];
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
.setMockMethodCallHandler(channel, (MethodCall methodCall) async {
calls.add(methodCall);
return true;
});
expect(await platform.closeTexture(7), true);
expect(await platform.closeTexture(8, recycle: true), true);
expect(calls.map((c) => c.method), ['closeTexture', 'closeTexture']);
expect(calls[0].arguments, {'key': 7, 'recycle': false});
expect(calls[1].arguments, {'key': 8, 'recycle': true});
});
} }

View file

@ -1,6 +1,8 @@
// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`.
import 'dart:typed_data'; import 'dart:typed_data';
import 'package:flutter_test/flutter_test.dart'; import 'package:flutter_test/flutter_test.dart';
import 'package:texture_rgba_renderer/texture_rgba_renderer.dart';
import 'package:texture_rgba_renderer/texture_rgba_renderer_platform_interface.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_platform_interface.dart';
import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart';
import 'package:plugin_platform_interface/plugin_platform_interface.dart'; import 'package:plugin_platform_interface/plugin_platform_interface.dart';
@ -11,8 +13,13 @@ class MockTextureRgbaRendererPlatform
@override @override
Future<String?> getPlatformVersion() => Future.value('42'); Future<String?> getPlatformVersion() => Future.value('42');
final closed = <List<Object>>[];
@override @override
Future<bool> closeTexture(int key) => Future.value(true); Future<bool> closeTexture(int key, {bool recycle = false}) {
closed.add([key, recycle]);
return Future.value(true);
}
@override @override
Future<int> createTexture(int key) => Future.value(1); Future<int> createTexture(int key) => Future.value(1);
@ -35,4 +42,18 @@ void main() {
test('$MethodChannelTextureRgbaRenderer is the default instance', () { test('$MethodChannelTextureRgbaRenderer is the default instance', () {
expect(initialPlatform, isInstanceOf<MethodChannelTextureRgbaRenderer>()); expect(initialPlatform, isInstanceOf<MethodChannelTextureRgbaRenderer>());
}); });
// Kitedesk fork (B212).
test('closeTexture forwards recycle', () async {
final fake = MockTextureRgbaRendererPlatform();
TextureRgbaRendererPlatform.instance = fake;
final renderer = TextureRgbaRenderer();
expect(await renderer.closeTexture(9), true);
expect(await renderer.closeTexture(10, recycle: true), true);
expect(fake.closed, [
[9, false],
[10, true],
]);
TextureRgbaRendererPlatform.instance = initialPlatform;
});
} }

58
windows/test/run_tests.sh Executable file
View file

@ -0,0 +1,58 @@
#!/usr/bin/env bash
# Kitedesk fork, 2026: builds windows/test/texture_rgba_renderer_plugin_test.cc
# on Linux with the plugin sources and the C++ client wrapper of the Flutter
# Windows engine, and runs each test in its own process. The engine files come
# from FLUTTER_WINDOWS_ENGINE, by default the windows-x64 engine artifacts of the
# Flutter SDK on PATH (or FLUTTER_ROOT) as `flutter precache --windows` leaves
# them: the C headers and cpp_client_wrapper/. No display, GPU or Windows needed.
# run_tests.sh -Wall -Werror build
# run_tests.sh --asan the same with AddressSanitizer and UBSan
# run_tests.sh --tsan the same with ThreadSanitizer
# OUT_DIR (default: a new temporary directory) receives the test binary.
set -euo pipefail
here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
if [ -z "${FLUTTER_WINDOWS_ENGINE:-}" ]; then
root=${FLUTTER_ROOT:-$(dirname "$(dirname "$(readlink -f "$(command -v flutter)")")")}
FLUTTER_WINDOWS_ENGINE=$root/bin/cache/artifacts/engine/windows-x64
fi
engine=$FLUTTER_WINDOWS_ENGINE
wrapper=$engine/cpp_client_wrapper
[ -f "$engine/flutter_texture_registrar.h" ] && [ -f "$wrapper/core_implementations.cc" ] || {
echo "no Flutter Windows engine headers and client wrapper in $engine" \
"(flutter precache --windows, or set FLUTTER_WINDOWS_ENGINE)" >&2
exit 2
}
out=${OUT_DIR:-$(mktemp -d)}
mkdir -p "$out"
# The client wrapper headers expect <cstdint> to come with the standard headers,
# as MSVC's do; libstdc++'s do not.
flags=(-std=c++17 -Wall -Werror -O1 -g -pthread -include cstdint -DFLUTTER_PLUGIN_IMPL '-D__declspec(x)=')
case "${1:-}" in
"") ;;
--asan) flags+=('-fsanitize=address,undefined' -fno-omit-frame-pointer -fno-sanitize-recover=undefined) ;;
--tsan)
flags+=(-fsanitize=thread)
export TSAN_OPTIONS=${TSAN_OPTIONS:-halt_on_error=1}
;;
*) echo "usage: $0 [--asan | --tsan]" >&2; exit 2 ;;
esac
bin=$out/texture_rgba_renderer_plugin_test
"${CXX:-clang++}" "${flags[@]}" -I"$here/shim" -I"$wrapper/include" -I"$engine" \
"$here/texture_rgba_renderer_plugin_test.cc" \
"$here/../texture_rgba.cpp" "$here/../texture_rgba_renderer_plugin.cpp" \
"$here/../texture_rgba_renderer_plugin_c_api.cpp" \
"$wrapper/core_implementations.cc" "$wrapper/plugin_registrar.cc" "$wrapper/standard_codec.cc" \
-o "$bin"
count=0
failed=0
for test in $("$bin" --list); do
count=$((count + 1))
if "$bin" "$test"; then
echo "PASS $test"
else
echo "FAIL $test"
failed=$((failed + 1))
fi
done
echo "$count tests, $((count - failed)) passed, $failed failed"
[ "$failed" -eq 0 ]

View file

@ -0,0 +1,3 @@
// Kitedesk fork, 2026: test-only stand-in for <VersionHelpers.h> (windows/test).
// The plugin includes it but uses nothing from it. Licensed under the Apache
// License, Version 2.0, like the rest of this package.

View file

@ -0,0 +1,63 @@
// Kitedesk fork, 2026: test-only stand-in for flutter_windows.h of the Flutter
// Windows engine (a18df97c) with the declarations that the client wrapper's
// plugin_registrar_windows.h and flutter_view.h use; windows/test defines them.
// Licensed under the Apache License, Version 2.0, like the rest of this
// package.
#ifndef KD_TEST_SHIM_FLUTTER_WINDOWS_H_
#define KD_TEST_SHIM_FLUTTER_WINDOWS_H_
#include <stddef.h>
#include <stdint.h>
#include <windows.h>
#include "flutter_export.h"
#include "flutter_messenger.h"
#include "flutter_plugin_registrar.h"
#if defined(__cplusplus)
extern "C" {
#endif
struct IDXGIAdapter;
struct FlutterDesktopView;
typedef struct FlutterDesktopView* FlutterDesktopViewRef;
typedef int64_t FlutterDesktopViewId;
typedef bool (*FlutterDesktopWindowProcCallback)(HWND /* hwnd */,
UINT /* uMsg */,
WPARAM /*wParam*/,
LPARAM /* lParam*/,
void* /* user data */,
LRESULT* result);
FLUTTER_EXPORT HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view);
FLUTTER_EXPORT struct IDXGIAdapter* FlutterDesktopViewGetGraphicsAdapter(
FlutterDesktopViewRef view);
FLUTTER_EXPORT FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(
FlutterDesktopPluginRegistrarRef registrar);
FLUTTER_EXPORT FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById(
FlutterDesktopPluginRegistrarRef registrar,
FlutterDesktopViewId view_id);
FLUTTER_EXPORT void
FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate(
FlutterDesktopPluginRegistrarRef registrar,
FlutterDesktopWindowProcCallback delegate,
void* user_data);
FLUTTER_EXPORT void
FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate(
FlutterDesktopPluginRegistrarRef registrar,
FlutterDesktopWindowProcCallback delegate);
#if defined(__cplusplus)
} // extern "C"
#endif
#endif // KD_TEST_SHIM_FLUTTER_WINDOWS_H_

View file

@ -0,0 +1,17 @@
// Kitedesk fork, 2026: test-only stand-in for <windows.h>, so that the plugin
// and the engine's C++ client wrapper build on Linux for windows/test. It has
// only the types those headers use. Licensed under the Apache License,
// Version 2.0, like the rest of this package.
#ifndef KD_TEST_SHIM_WINDOWS_H_
#define KD_TEST_SHIM_WINDOWS_H_
#include <stdint.h>
typedef struct HWND__* HWND;
typedef unsigned int UINT;
typedef uintptr_t WPARAM;
typedef intptr_t LPARAM;
typedef intptr_t LRESULT;
#endif // KD_TEST_SHIM_WINDOWS_H_

File diff suppressed because it is too large Load diff

View file

@ -1,3 +1,6 @@
// Modified by the Kitedesk fork (2026, B252): no UnregisterTexture in the
// destructor; Terminate and FreeBuffers for closeTexture.
#include "texture_rgba.h" #include "texture_rgba.h"
#include <iostream> #include <iostream>
@ -11,11 +14,6 @@ TextureRgba::TextureRgba(flutter::TextureRegistrar *texture_registrar)
this->texture_id_ = texture_registrar->RegisterTexture(texture_.get()); this->texture_id_ = texture_registrar->RegisterTexture(texture_.get());
} }
TextureRgba::~TextureRgba()
{
texture_registrar_->UnregisterTexture(texture_id_);
}
void TextureRgba::MarkVideoFrameAvailable( void TextureRgba::MarkVideoFrameAvailable(
std::vector<uint8_t> &buffer, size_t width, size_t height) std::vector<uint8_t> &buffer, size_t width, size_t height)
{ {
@ -45,6 +43,11 @@ void TextureRgba::MarkVideoFrameAvailable2(const uint8_t* buffer, const size_t b
return; return;
} }
const std::lock_guard<std::mutex> lock(mutex_); const std::lock_guard<std::mutex> lock(mutex_);
if (terminated_)
{
// Closed while the session still pushes frames to this pointer.
return;
}
int bg_index = fg_index_ ^ 1; int bg_index = fg_index_ ^ 1;
buffer_tmp_[bg_index].assign(buffer, buffer + buffer_length); buffer_tmp_[bg_index].assign(buffer, buffer + buffer_length);
width_[bg_index] = width; width_[bg_index] = width;
@ -61,6 +64,11 @@ void TextureRgba::MarkVideoFrameAvailable2(const uint8_t* buffer, const size_t b
inline const FlutterDesktopPixelBuffer *TextureRgba::buffer() inline const FlutterDesktopPixelBuffer *TextureRgba::buffer()
{ {
const std::lock_guard<std::mutex> lock(mutex_); const std::lock_guard<std::mutex> lock(mutex_);
if (terminated_)
{
// Closed; the engine may draw the texture until it has unregistered it.
return nullptr;
}
if (buff_ready_) if (buff_ready_)
{ {
fg_index_ ^= 1; fg_index_ ^= 1;
@ -71,3 +79,18 @@ inline const FlutterDesktopPixelBuffer *TextureRgba::buffer()
} }
return &this->flutter_pixel_buffer_; return &this->flutter_pixel_buffer_;
} }
void TextureRgba::Terminate()
{
const std::lock_guard<std::mutex> lock(mutex_);
terminated_ = true;
}
void TextureRgba::FreeBuffers()
{
const std::lock_guard<std::mutex> lock(mutex_);
std::vector<uint8_t>().swap(buffer_tmp_[0]);
std::vector<uint8_t>().swap(buffer_tmp_[1]);
flutter_pixel_buffer_.buffer = nullptr;
buff_ready_ = false;
}

View file

@ -1,7 +1,14 @@
// Modified by the Kitedesk fork (2026, B252): the texture no longer
// unregisters itself when destroyed (closeTexture does, and the plugin keeps
// the object alive until the engine is done with it); a closed texture drops
// pushed frames, hands the engine no buffer, and frees its frame buffers once
// the engine has unregistered it.
#ifndef TEXTURE_RGBA_H_ #ifndef TEXTURE_RGBA_H_
#define TEXTURE_RGBA_H_ #define TEXTURE_RGBA_H_
#include <flutter/texture_registrar.h> #include <flutter/texture_registrar.h>
#include <atomic>
#include <mutex> #include <mutex>
#include <chrono> #include <chrono>
@ -9,7 +16,6 @@ class TextureRgba
{ {
public: public:
TextureRgba(flutter::TextureRegistrar* texture_registrar); TextureRgba(flutter::TextureRegistrar* texture_registrar);
~TextureRgba();
void MarkVideoFrameAvailable(std::vector<uint8_t>& buffer, size_t width, size_t height); void MarkVideoFrameAvailable(std::vector<uint8_t>& buffer, size_t width, size_t height);
@ -19,12 +25,23 @@ public:
const FlutterDesktopPixelBuffer* buffer(); const FlutterDesktopPixelBuffer* buffer();
// Closes the texture: frames pushed from now on are dropped without
// touching the texture registrar, and the engine gets no buffer any more.
void Terminate();
// Frees the frame buffers. Call after Terminate, once the engine has
// unregistered the texture and so no longer reads them.
void FreeBuffers();
private: private:
FlutterDesktopPixelBuffer flutter_pixel_buffer_{}; FlutterDesktopPixelBuffer flutter_pixel_buffer_{};
flutter::TextureRegistrar* texture_registrar_ = nullptr; flutter::TextureRegistrar* texture_registrar_ = nullptr;
std::unique_ptr<flutter::TextureVariant> texture_ = nullptr; std::unique_ptr<flutter::TextureVariant> texture_ = nullptr;
int64_t texture_id_; int64_t texture_id_;
std::mutex mutex_; std::mutex mutex_;
// Set and read with mutex_ held, so that no frame is copied or announced
// to the engine after Terminate returns.
std::atomic<bool> terminated_{false};
int fg_index_ = 0; int fg_index_ = 0;
bool buff_ready_ = false; bool buff_ready_ = false;
size_t width_[2]; size_t width_[2];

View file

@ -1,3 +1,9 @@
// Modified by the Kitedesk fork (2026, B252): closeTexture no longer destroys
// the texture before the engine is done with it, and keeps it for good unless
// "recycle" is set; the textures of a closing engine are kept the same way;
// createTexture of a key in use answers -1; getTexturePtr of a key that is not
// open answers 0.
#include "texture_rgba_renderer_plugin.h" #include "texture_rgba_renderer_plugin.h"
// This must be included before many other Windows headers. // This must be included before many other Windows headers.
@ -11,10 +17,32 @@
#include <flutter/standard_method_codec.h> #include <flutter/standard_method_codec.h>
#include <memory> #include <memory>
#include <mutex>
#include <sstream> #include <sstream>
#include <vector>
namespace texture_rgba_renderer { namespace texture_rgba_renderer {
namespace {
// Textures closed while frames may still be pushed to the pointer from
// getTexturePtr: closeTexture without "recycle" (a tab moving to another
// window keeps its session's pointer), or an engine going away first. They are
// never destroyed, so such a push finds a closed texture and not freed memory,
// and their address is never handed out again for another texture (ABA). Their
// lifetime is the process; each one keeps the object, not its frame buffers.
struct Retired {
std::mutex mutex;
std::vector<std::shared_ptr<TextureRgba>> textures;
};
Retired& retired() {
static Retired* instance = new Retired();
return *instance;
}
} // namespace
// static // static
void TextureRgbaRendererPlugin::RegisterWithRegistrar( void TextureRgbaRendererPlugin::RegisterWithRegistrar(
flutter::PluginRegistrarWindows *registrar) { flutter::PluginRegistrarWindows *registrar) {
@ -38,7 +66,28 @@ TextureRgbaRendererPlugin::TextureRgbaRendererPlugin() {
this->texture_registrar = nullptr; this->texture_registrar = nullptr;
} }
TextureRgbaRendererPlugin::~TextureRgbaRendererPlugin() {} TextureRgbaRendererPlugin::~TextureRgbaRendererPlugin() {
// The engine is going away (its texture registrar outlives the plugins), and
// sessions may still push frames to these textures.
for (auto &entry : textures_) {
CloseTexture(std::move(entry.second), false);
}
}
void TextureRgbaRendererPlugin::CloseTexture(
std::unique_ptr<TextureRgba> texture, bool recycle) {
std::shared_ptr<TextureRgba> closed = std::move(texture);
closed->Terminate();
if (!recycle) {
std::lock_guard<std::mutex> lock(retired().mutex);
retired().textures.push_back(closed);
}
// The engine removes the texture on its raster thread, which may draw it
// until then, and calls back there. Only then are the frame buffers freed,
// and a recycled texture is destroyed with the last reference.
this->texture_registrar->UnregisterTexture(closed->texture_id(),
[closed] { closed->FreeBuffers(); });
}
void TextureRgbaRendererPlugin::HandleMethodCall( void TextureRgbaRendererPlugin::HandleMethodCall(
const flutter::MethodCall<flutter::EncodableValue> &method_call, const flutter::MethodCall<flutter::EncodableValue> &method_call,
@ -52,16 +101,27 @@ void TextureRgbaRendererPlugin::HandleMethodCall(
it->second = std::make_unique<TextureRgba>(this->texture_registrar); it->second = std::make_unique<TextureRgba>(this->texture_registrar);
result->Success(flutter::EncodableValue(it->second->texture_id())); result->Success(flutter::EncodableValue(it->second->texture_id()));
} }
else {
// The key is in use. Without an answer the Dart future never completes.
result->Success(flutter::EncodableValue(int64_t(-1)));
}
} }
else if (method_call.method_name().compare("closeTexture") == 0) { else if (method_call.method_name().compare("closeTexture") == 0) {
auto args = std::get<flutter::EncodableMap>(*method_call.arguments()); auto args = std::get<flutter::EncodableMap>(*method_call.arguments());
auto key = std::get<int>(args.at(flutter::EncodableValue("key"))); auto key = std::get<int>(args.at(flutter::EncodableValue("key")));
if (textures_.find(key) == textures_.end()) { auto it = textures_.find(key);
if (it == textures_.end()) {
result->Success(flutter::EncodableValue(false)); result->Success(flutter::EncodableValue(false));
} }
else { else {
this->texture_registrar->UnregisterTexture(textures_[key]->texture_id()); // "recycle": true promises that nothing pushes frames to the pointer
textures_.erase(key); // from getTexturePtr any more, so the texture may be destroyed.
auto recycle = args.find(flutter::EncodableValue("recycle"));
const bool* recycle_value = recycle == args.end()
? nullptr : std::get_if<bool>(&recycle->second);
CloseTexture(std::move(it->second),
recycle_value != nullptr && *recycle_value);
textures_.erase(it);
result->Success(flutter::EncodableValue(true)); result->Success(flutter::EncodableValue(true));
} }
} }
@ -83,7 +143,8 @@ void TextureRgbaRendererPlugin::HandleMethodCall(
auto args = std::get<flutter::EncodableMap>(*method_call.arguments()); auto args = std::get<flutter::EncodableMap>(*method_call.arguments());
auto key = std::get<int>(args.at(flutter::EncodableValue("key"))); auto key = std::get<int>(args.at(flutter::EncodableValue("key")));
if (textures_.find(key) == textures_.end()) { if (textures_.find(key) == textures_.end()) {
result->Success(flutter::EncodableValue(-1)); // Not open (e.g. closed meanwhile): no pointer for the session.
result->Success(flutter::EncodableValue(0));
} }
else { else {
// Return an address. // Return an address.

View file

@ -1,3 +1,7 @@
// Modified by the Kitedesk fork (2026, B252): closeTexture keeps the texture
// alive until the engine has unregistered it, and for good unless "recycle"
// says that nothing pushes frames to its pointer any more.
#ifndef FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_ #ifndef FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_
#define FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_ #define FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_
@ -31,6 +35,8 @@ class TextureRgbaRendererPlugin : public flutter::Plugin {
void HandleMethodCall( void HandleMethodCall(
const flutter::MethodCall<flutter::EncodableValue> &method_call, const flutter::MethodCall<flutter::EncodableValue> &method_call,
std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result); std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
void CloseTexture(std::unique_ptr<TextureRgba> texture, bool recycle);
}; };
} // namespace texture_rgba_renderer } // namespace texture_rgba_renderer