Kitedesk fork of github.com/rustdesk-org/flutter_texture_rgba_renderer (Apache-2.0, upstream 42797e0f). Branch kd/b212-texture-leak: Linux texture lifetime fixes (B212).
Find a file
yunchan 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
.github/workflows opt: readme 2023-02-17 14:06:30 +08:00
.vscode opt: try to fix the memory corrupt issue on Linux 2023-02-28 15:37:20 +08:00
example bump: 0.0.13 2023-03-14 06:07:04 +00:00
lib G26: keep Windows textures alive through asynchronous unregister 2026-10-29 12:13:44 +09:00
linux linux: recycle closed textures per engine, closeTexture(recycle:) (Kitedesk B212) 2026-10-11 15:38:06 +09:00
macos macos: add headless texture tests (Kitedesk T-4204) 2026-11-15 09:56:22 +09:00
res update: README.md 2023-02-20 16:23:07 +08:00
test linux: recycle closed textures per engine, closeTexture(recycle:) (Kitedesk B212) 2026-10-11 15:38:06 +09:00
windows G26: keep Windows textures alive through asynchronous unregister 2026-10-29 12:13:44 +09:00
.gitignore feat: init repo 2023-02-16 15:03:12 +08:00
.metadata feat: init repo 2023-02-16 15:03:12 +08:00
analysis_options.yaml feat: init repo 2023-02-16 15:03:12 +08:00
CHANGELOG.md bump: 0.0.16 2023-03-25 21:35:14 +08:00
LICENSE feat: init repo 2023-02-16 15:03:12 +08:00
pubspec.yaml bump: 0.0.16 2023-03-25 21:35:14 +08:00
README.md Refact/stride align (#8) 2023-03-03 09:46:33 +08:00

Texture Rgba Renderer

A general texture helper which brings both of high and low level api to handle BGRA data for Flutter. Only one time frame copy required, and aims to get a full hardware acceleration.

This plugin is originally developed for RustDesk.

Now it's in active development, which aims to improve the memory usage and performance.

Pub Version FOSSA Status

Platform Support

The plugin aims to provide opengl impl for the texture, which bring a better performance instead of FFI + CustomPainter.

  • Linux
  • Windows
  • MacOS

Note: Please use the BGRA format for ALL platforms.

Getting Started

Create a texture by calling createTexture.

_textureRgbaRendererPlugin.createTexture(key).then((textureId) {
      if (textureId != -1) {
        debugPrint("Texture register success, textureId=$textureId");
        setState(() {
          this.textureId = textureId;
        });
      } else {
        return;
      }
    });

Transfer rgba data by calling onRgba.

data = mockPicture(width, height);
final res = await _textureRgbaRendererPlugin.onRgba(key, data!, height, width);
if (!res) {
    debugPrint("WARN: render failed");
}

Close a texture by calling closeTexture.

if (key != -1) {
    _textureRgbaRendererPlugin.closeTexture(key);
}

Check the example for details.

API

For a better convienent interface for both dart and native developers, the plugin provides two kinds of APi to render the frame.

Benchmark:

macOS Bigsur qemu vm (4+8G), with OpenGL accelerated. Release build.

API Kind FPS(Average)
Method Channel (Dart) API ~45
Native API ~670

Conclusion:

For a better performance, please use Native API provided by this plugin.

Dart API

You can create/close a texure with the dart API provided by this plugin. And you can also provide the BGRA data to the texure via onRgba function.

class TextureRgbaRenderer {

  /// Create a texture with unique identifier [key].
  /// 
  /// @return a texture id which can be used with
  /// ```dart
  /// Texture(textureId: textureId)
  /// ```
  Future<int> createTexture(int key) {
    return TextureRgbaRendererPlatform.instance.createTexture(key); 
  }

  /// Close a texture with unique identifier [key].
  /// 
  /// @return a boolean to indicate whether the operation is sucessfully executed.
  Future<bool> closeTexture(int key) {
    return TextureRgbaRendererPlatform.instance.closeTexture(key); 
  }

  /// Provide the rgba data to the texture.
  Future<bool> onRgba(int key, Uint8List data, int height, int width) {
     return TextureRgbaRendererPlatform.instance.onRgba(key, data, height, width); 
  }

  /// For native API.
  Future<int> getTexturePtr(int key) async {
    final ptr =
        await methodChannel.invokeMethod('getTexturePtr', {"key": key}) ??
            false;
    return ptr;
  }
}

Native API

Note that the onRgba function is not called immediately. It depends on the execution scheduler of Flutter. To solve the problem, the plugin provide the low level function on all 3 pc platforms, which can make them be executed immediately.

void FlutterRgbaRendererPluginOnRgba(void* texture_rgba_ptr, const uint8_t* buffer, int len, int width, int height, int stride_align)

You could use the native API in other programing languages. A dart quick example:

/// The `Native` class is bundled in this plugin.
typedef F1 = Void Function(Pointer<Void> ptr, Pointer<Uint8> buffer, Int len,
    Int32 width, Int32 height, Int stride_align);
typedef F1Dart = void Function(Pointer<Void> ptr, Pointer<Uint8> buffer,
    int len, int width, int height, int stride_align);

class Native {
  Native._();

  static Native get _instance => Native._()..init();
  static Native get instance => _instance;

  late F1Dart onRgba;

  init() {
    final lib = DynamicLibrary.process();
    onRgba = lib.lookupFunction<F1, F1Dart>("FlutterRgbaRendererPluginOnRgba");
  }
}
...

// Call
Native.instance.onRgba(ptr_from_method_getTexturePtr, bgra_data, width, height);

Note that the buffer is not taken by the plugin, you should handle the lifecycle of the buffer yourself.

Both example usages of two kinds of onRgba can be found in example folder.

Thanks

License

FOSSA Status