Flutter Native Vision Camera #

A high-performance, FFI-powered camera plugin for Flutter that puts efficiency and hardware control first.

Built for developers who need more than just a preview: Real-time AI, low-latency filters, and professional-grade video control.

Why use this instead of camera? #

The official camera package is great for simple use cases, but it often falls short when building high-performance vision applications (AI, QR scanning, custom filters). This package was built to solve those limitations.

🚀 Key Advantages #

Features #

• Zero-Copy Rendering: Frames go directly from the camera sensor to the GPU and then to Flutter's Texture widget. No expensive copying or CPU-side bitmap conversion.
• Physical Orientation Engine: High-fidelity rotation sensing using native OrientationEventListener. Recorded videos and previews always have the correct orientation, even on orientation-locked apps.
• Integrated MLKit: High-speed, hardware-accelerated barcode and QR code scanning.
• Unified Request Loop: Change zoom, torch, exposure, or recording state without dropping frame buffers.
• FFI Background Pipeline: Process camera frames in C++/Rust/Dart FFI with zero memory copying.

Frame Processors #

Frame processors allow you to run code for every frame the camera captures. Unlike the standard camera plugin, flutter_native_vision_camera runs these synchronously on a background thread.

How it works #

1. Zero Latency: Frames are delivered to the processor as soon as they are available from the sensor.
2. Background Execution: Your code runs on a separate background Isolate or in Native C++, so the main UI thread stays at a silky smooth 60/120 FPS.
3. Memory Safety: The Frame object is valid only for the duration of the callback. If you need to keep data, copy it out of the frame's buffer.

Dart Frame Processor #

Use for ML tasks (using google_mlkit_* or tflite_flutter) or image manipulation in Dart.

await controller.setFrameProcessor((frame) {
  // 'frame' contains pointers to YUV/RGB buffers
  final bytes = frame.getPlane(0).bytes; // Direct access to Y-plane
  
  // Do your analysis here...
});

🚀 High-Performance FFI Plugins #

One of the unique features of flutter_native_vision_camera is the ability to write Synchronous C++ Plugins.

Instead of sending expensive image data back and forth over Method Channels or into separate Dart Isolates, you can hook directly into the native frame loop.

// Your high-performance C++ code
void onFrame(FrameHandle frame) {
    void* y_plane = Frame_getPlanePointer(frame, 0);
    // Do heavy AI math here on the background thread
}

Getting Started #

Installation #

Add to your pubspec.yaml:

dependencies:
  flutter_native_vision_camera: ^1.0.0

Basic Usage #

final controller = CameraController();

// 1. Initialize with a device
await controller.initialize(
  devices.first,
  enableVideo: true,
  codeScanner: CodeScannerConfiguration(),
);

// 2. Start streaming
await controller.setActive(true);

// 3. Listen for codes
controller.onCodeScanned.listen((codes) {
  print('Detected: ${codes.first.value}');
});

// 4. Render in your widget tree
ValueListenableBuilder<CameraState>(
  valueListenable: controller,
  builder: (context, state, _) {
    if (state == CameraState.uninitialized) return CircularProgressIndicator();
    return Texture(textureId: controller.textureId!);
  },
)

Lifecycle Management #

Keeping the camera hardware active is resource-intensive. You must dispose of the controller when it's no longer needed to release the hardware and stop background threads.

@override
void dispose() {
  // Shuts down the camera, sessions, and background isolates
  controller.dispose(); 
  super.dispose();
}

Video Recording & Zooming #

Unlike many other plugins, you can smoothly zoom or toggle the torch while recording video without causing any frame drops or freezes.

await controller.startRecording('/path/to/video.mp4');

// This call seamlessly updates the ongoing recording request
await controller.setZoom(2.5); 

await controller.stopRecording();

Platform Support #

Credits & Attribution #

This package is a Flutter port and expansion of the concepts introduced by react-native-vision-camera, originally created by Marc Rousavy.

We aim to bring the same high-performance, low-level camera control to the Flutter ecosystem, while leveraging Flutter's unique strengths like synchronous FFI and specialized Texture rendering.

License #

MIT