# Accessing ZED camera frames before SDK processing for low-latency streaming (raw NV12 / async retrieval alternative?)

**URL:** <https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439>\
**Category:** C++\
**Tags:** zed-gstreamer, sdk, jetson\
**Created:** [June 15, 2026, 8:17pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439 "2026-06-15T20:17:48Z")\
**Posts on this page:** 7\
**Page:** 1

<div class="post-metadata">

**Author:** ![ShashankVSS](https://community.stereolabs.com/user_avatar/community.stereolabs.com/shashankvss/32/6120_2.png) [@ShashankVSS](https://community.stereolabs.com/u/ShashankVSS)\
**Post date:** [June 15, 2026, 8:17pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/1 "2026-06-15T20:17:48Z")

</div>

Hi [Stereolabs](https://www.stereolabs.com/) team,

We’re currently using a ZED camera for positional tracking alongside a low-latency video feed for an RC controller / teleoperation workflow.

For the video path, we’re using the Raw Buffers API to retrieve raw NV12 buffers and stream them over GStreamer for low-latency transport. Our current flow is roughly:

```auto
zed.grab(runtime_params);
zed.retrieveImage(raw_buffer);

```

where `retrieveImage(raw_buffer)` gives us the raw NV12 `NvBufSurface`, which we push directly into a GStreamer pipeline.

The issue we’re seeing is that **`zed.grab()`** latency appears to vary significantly depending on lighting conditions / scene complexity. Under some conditions, `grab()` becomes noticeably slower, introducing up to ~300 ms of delay in the RC video feed.

We are still using positional tracking, so we understand some SDK processing is required. However, our main concern is the video path latency, and it seems like delays inside `grab()` are affecting when the raw image buffer becomes available.

Our goal is to retrieve frames for streaming as early as possible, ideally before non-essential SDK image processing occurs, while still allowing positional tracking to run in parallel.

Specifically, we’re wondering if there is currently a way to:

- Access raw or minimally processed frames (preferably NV12) with lower latency

- Decouple frame retrieval from heavier SDK processing inside `grab()`

- Retrieve frames asynchronously while positional tracking / other SDK processing continues in parallel

I found references to the deprecated `async_image_retrieval` functionality, which sounds very close to what we’re trying to achieve. Is there a current equivalent approach in the SDK, or another recommended method for low-latency frame access?

Alternatively, is there any plan to expose a lower-level frame access path or reintroduce similar functionality for latency-sensitive applications like teleoperation / RC video streaming?

Thanks!

---

<div class="post-metadata">

**Author:** ![Myzhar](https://community.stereolabs.com/user_avatar/community.stereolabs.com/myzhar/32/11_2.png) [@Myzhar](https://community.stereolabs.com/u/Myzhar)\
**Post date:** [June 16, 2026, 5:34pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/2 "2026-06-16T17:34:42Z")

</div>

Hi @ShashankVSS  
The feature you described is already available by using the `read` and `grab` API functions.

You can call `read` when you only need the image buffer; then you can call `grab` when you need the ZED SDK to process all the data.

Read more in the API documentation:

> **[Camera Class Reference | C++ API Reference | Stereolabs](https://www.stereolabs.com/docs/api/classsl_1_1Camera.html#a721beb13a5f7117fb073ac4341289b90)**
>
> This class serves as the primary interface between the camera and the various features provided by the SDK. More...

---

<div class="post-metadata">

**Author:** ![ShashankVSS](https://community.stereolabs.com/user_avatar/community.stereolabs.com/shashankvss/32/6120_2.png) [@ShashankVSS](https://community.stereolabs.com/u/ShashankVSS)\
**Post date:** [June 17, 2026, 7:07pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/3 "2026-06-17T19:07:33Z")

</div>

Thanks, that helps clarify the intended use of read() vs grab().

One thing I’m still not understanding is how this helps maintain a high-rate video stream if grab() remains blocking.

For example, if I do:

```auto
zed.read();
zed.retrieveImage(raw_buffer); // stream frame immediately

zed.grab(runtime_params); // tracking/depth processing
zed.getPosition(pose);

```

then the frame is available earlier for that iteration, but if grab() takes 100-300 ms, I still can’t call read() again until grab() returns. That would still cause me to miss several camera frames and reduce the effective video update rate.

So my question is:

- Is it supported to call read()/retrieveImage() continuously from one thread while another thread calls grab()/getPosition() on the same sl::Camera instance?

- Or is there another SDK pattern that allows image acquisition to continue while tracking/depth processing is running?

Our goal is to keep a continuous low-latency video stream while allowing positional tracking to run at a lower rate if necessary.

---

<div class="post-metadata">

**Author:** ![Myzhar](https://community.stereolabs.com/user_avatar/community.stereolabs.com/myzhar/32/11_2.png) [@Myzhar](https://community.stereolabs.com/u/Myzhar)\
**Post date:** [June 18, 2026, 4:22pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/4 "2026-06-18T16:22:04Z")

</div>

> [@ShashankVSS](#):
>
> One thing I’m still not understanding is how this helps maintain a high-rate video stream if grab() remains blocking.

You should call `grab` only when you need it.

> [@ShashankVSS](#):
>
> Is it supported to call read()/retrieveImage() continuously from one thread while another thread calls grab()/getPosition() on the same sl::Camera instance?

No, this is not multithread-safe behavior.

---

<div class="post-metadata">

**Author:** ![ShashankVSS](https://community.stereolabs.com/user_avatar/community.stereolabs.com/shashankvss/32/6120_2.png) [@ShashankVSS](https://community.stereolabs.com/u/ShashankVSS)\
**Post date:** [June 18, 2026, 5:11pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/5 "2026-06-18T17:11:37Z")

</div>

Thanks for confirming.

In that case, if `grab()` is only called occasionally, does positional tracking only receive visual updates on those `grab()` calls?

Our concern is that reducing `grab()` frequency may preserve video rate, but could reduce positional tracking quality because the tracking pipeline is no longer processing every camera frame.

Is there a recommended approach for maintaining high-rate video while preserving positional tracking quality? For example, would the newer Sensors API with pipelined `process()` be the intended solution for this use case?

---

<div class="post-metadata">

**Author:** ![Myzhar](https://community.stereolabs.com/user_avatar/community.stereolabs.com/myzhar/32/11_2.png) [@Myzhar](https://community.stereolabs.com/u/Myzhar)\
**Post date:** [June 19, 2026, 12:02pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/6 "2026-06-19T12:02:30Z")

</div>

> [@ShashankVSS](#):
>
> In that case, if `grab()` is only called occasionally, does positional tracking only receive visual updates on those `grab()` calls?

Yes, Positional Tracking processing is performed when you call “grab”.

---

<div class="post-metadata">

**Author:** ![Myzhar](https://community.stereolabs.com/user_avatar/community.stereolabs.com/myzhar/32/11_2.png) [@Myzhar](https://community.stereolabs.com/u/Myzhar)\
**Post date:** [June 19, 2026, 12:04pm UTC](https://community.stereolabs.com/t/accessing-zed-camera-frames-before-sdk-processing-for-low-latency-streaming-raw-nv12-async-retrieval-alternative/11439/7 "2026-06-19T12:04:09Z")

</div>

> [@ShashankVSS](#):
>
> Is there a recommended approach for maintaining high-rate video while preserving positional tracking quality? For example, would the newer Sensors API with pipelined `process()` be the intended solution for this use case?

You can apply what’s described here for the ROS 2 Wrapper.  
It applies identically to native SDK applications:

> **[Stereo Node Frequency Tuning | StereoLabs](https://docs.stereolabs.com/docs/integrations/ros-2/node-frequency-tuning)**
