3D visionTroubleshooting

USB bandwidth for multi-stream depth cameras on embedded hosts

Multi-stream depth cameras need a USB bandwidth budget: sum depth, infra, RGB and IMU streams, compare with USB 2.0 and 3.x ceilings, and fix the drop cycle.

LumaSpec Vision11 min read Share on LinkedIn

On this page 9 sections
  1. 01The error signature tells you the link is starving
  2. 02Budget every stream before blaming the driver
  3. 03Sizing the link for 640 × 480 depth at 90 fps plus color at 60 fps
  4. 04What each link actually carries
  5. 05Likely causes, tested in order
  6. 06Fix it in this order
  7. 07When the budget fits and it still drops
  8. 08Prevention checklist
  9. 09Questions

A depth camera that enumerates cleanly and then floods the log with control-transfer errors is rarely a broken driver. It is a bandwidth budget that does not fit the link it landed on. One stereo camera running depth at 90 fps plus color, infra and IMU can demand about 111 MB/s, while a USB 2.0 hop hiding behind a USB 3-shaped plug, hub or cable carries 35-40 MB/s. This guide gives you the arithmetic to size a multi-stream set, the tests that find the downgraded hop, and the fixes in the order that costs the least time. It is written for engineers running depth cameras with color and IMU streams on embedded Linux hosts and ARM boards.

The camera is found, its serial number reads back, firmware reports normally. Then streaming starts, and lines like “control_transfer returned error, error: No data available” arrive a few per second. Toggling the color stream on top of depth and infra is the usual trigger. A few seconds later the message changes to “No such device”, the driver reports the device disconnected, finds it again, and the cycle repeats.

Enumeration and control exchanges move trivial amounts of data, so a link that is electrically alive always passes them. Streaming claims bulk bandwidth continuously at the configured frame rate, and that is where a weak hop gives out. When the controller cannot service the endpoints in time, the stack resets the device; it re-enumerates and the loop closes. The same drop-and-rediscover pattern on generic USB cameras is worked through in USB camera connects then disconnects.

Two more details in the log narrow the cause. A startup line saying the requested stream configuration “is not supported” means the driver will keep re-requesting a rejected setup, and every retry costs a failed control transfer. And when frames arrive but stall instead of dropping, the link is marginal rather than impossible — that variant is covered in depth camera frames not updating.

Budget every stream before blaming the driver

Size the demand first. For each enabled stream, bandwidth in MB/s equals width in pixels times height in pixels times bytes per pixel times frame rate, divided by a million. Sum every enabled stream, add about 10% for framing and retries, and compare the total with the usable capacity of the link the camera actually negotiated. All MB/s in this guide are decimal: 1 MB is 1,000,000 bytes.

stream MB/s = width (px) × height (px) × bytes per pixel × fps ÷ 1,000,000 budget MB/s = Σ (enabled streams) × 1.1
Stream Pixel format Bytes per pixel
Depth Z16 2
Infra / mono Y8 1
Color RGB8 3

IMU streams look large in Hz and are tiny in bytes: a 400 Hz gyro and a 250 Hz accelerometer together stay under 0.1 MB/s. Leave them out of the MB/s budget, but remember they ride the same cable and the same device, so they drop when the link drops.

Take the stream set a common robot-perception driver launches by default: depth at 640 × 480 px and 90 fps in Z16, color at 640 × 480 px and 60 fps in RGB8, gyro at 400 Hz and accel at 250 Hz, plus an infra request at 848 × 480 px and 90 fps that the device refused at startup. Compare the sum with the negotiated link, not the plug.

  • Depth: 640 × 480 = 307,200 px per frame; × 2 bytes = 614,400 bytes per frame; × 90 fps = 55,296,000 bytes/s ≈ 55.3 MB/s.
  • Color: 640 × 480 × 3 = 921,600 bytes per frame; × 60 fps = 55,296,000 bytes/s ≈ 55.3 MB/s.
  • IMU: under 0.1 MB/s. Total: 55.3 + 55.3 ≈ 111 MB/s, or about 122 MB/s with the 10% framing margin.
  • The refused infra request, at 848 × 480 × 3 bytes × 90 fps, works out to 1,221,120 bytes per frame ≈ 109.9 MB/s — as large as depth and color combined. In the usual 8-bit mono mode the same geometry costs a third of that: 848 × 480 × 1 × 90 ≈ 36.6 MB/s.

The decision: 111 MB/s is roughly 3× the 35-40 MB/s a USB 2.0 path can carry, so this set cannot run through any 2.0-rated cable, hub or port. It is under a third of the ~400 MB/s a healthy 5 Gbps USB 3.x link carries, so a true SuperSpeed path runs it, and runs the mono infra stream too: 111 + 36.6 ≈ 148 MB/s, still under 40% of usable capacity. Keep a single 5 Gbps link under ~300 MB/s to leave margin for retries and a second device.

Link Line rate Usable, planning number The 111 MB/s stream set
USB 2.0 480 Mbps = 60 MB/s 35-40 MB/s fails, about 3× over
USB 3.x (5 Gbps) 5 Gbps = 625 MB/s ~400 MB/s fits with margin
GigE (1 Gbps) 1 Gbps = 125 MB/s ~110 MB/s borderline; cut fps

The usable column is what clean transfers sustain in practice, not the line rate: USB 2.0's 480 Mbps works out to 60 MB/s before framing, and no real link holds that. The same arithmetic — per-stream rate times bytes per frame times fps, summed per camera and per host — is how an NVR's storage and network get sized for many video streams, so the habit transfers to any multi-camera host.

Budget per controller, not per connector: the ports on one embedded board often share a single controller and its 5 Gbps. And trust the negotiated report, not the plug shape: when a camera reports a USB type of 2.1 or 2.0, some hop downgraded, and the camera enumerates as USB 2.0 on a USB 3.0 port guide shows how to chase it.

Likely causes, tested in order

Work down this list; the first three causes cover most cases.

  1. A USB 2.0 hop in the path. A passive cable wired for 2.0, a hub's 2.0 segment, or a port wired for 2.0 on the board. Test: read the negotiated speed per port from the SDK's device info or the OS USB tree (lsusb -t on Linux); anything reporting 2.x is the bottleneck. The stream-refusal side of this is covered in why low bandwidth stops streams starting on USB 2.0 and why a hub keeps raw streams from starting.
  2. A stream set larger than the link. Test: run the arithmetic above with your own width, height, fps and pixel formats, then compare with the negotiated link's usable number. It is a two-minute calculation that settles most “is it the driver or the wire” arguments.
  3. A configuration the device refuses, retried forever. Test: the startup line “stream configuration is not supported” just before the first control-transfer error. Fix it in the stream settings: request a combination the camera's mode list carries. The 848 × 480 px RGB8 request in the worked example is one such case; the same geometry in mono costs a third of the bytes.
  4. Power sagging under streaming load. A camera that idles quietly can sag once every sensor streams and its projector runs. An unpowered hub divides one port's allowance — 500 mA on USB 2.0, 900 mA on USB 3.x — across everything plugged into it. Test: run the camera alone, straight into the host, all streams on, then add back cable and hub one piece at a time until the errors return. The milder version is a hub that only drops frame rate mid-run — budget the hub's bandwidth first.
  5. The host cannot drain the buffers. Alignment, point clouds and per-frame filters run on the host CPU; when a small SoC falls behind, the endpoints back up and link errors follow the stall. Test: watch per-core CPU during streaming, switch off host-side filters, and compare sustained fps with the configured fps. The recording-heavy variant lives in why sustained recording FPS drops on an embedded vision box.

One more embedded-host quirk: the camera is a composite USB device — depth, color and the IMU's interface share one physical link — and host controllers differ in how they schedule composite endpoints. If the errors cluster when the IMU stream toggles on, check the host-side USB set-up; configuring composite HID hosts on embedded USB covers that layer.

Fix it in this order

  1. Confirm the negotiated USB type on the exact port the camera uses. Replace every 2.x hop before touching a single stream setting; this step alone clears most cases.
  2. Swap the cable. Passive SuperSpeed runs are trustworthy to about 3 m; past that, use a cable certified for the length or move to an active or optical run. Long marginal extension cables fail exactly when the heavy stream starts — the extension-cable case is that failure in detail. For bench and drag-chain runs, use a cable built for USB 3.0 duty:
Cables3 m USB3.0 camera cable, high-flex (drag chain) (LS-CBL-0219)LS-CBL-0219$62.00View partBuild a system with it
  1. Remove the unpowered hub, or power it. Commission on a direct connection; add a powered hub only when the topology forces one.
  2. Cut demand until the sum fits the link. Frame rate first: dropping depth from 90 to 30 fps takes the worked example from 55.3 to 18.4 MB/s (640 × 480 × 2 bytes × 30). Unused streams next: a second infra stream you never read is 27.6 MB/s of dead weight at this geometry (640 × 480 × 1 byte × 90 fps). Then crop the region of interest at the source — cropping before the host shrinks bandwidth and CPU together.
  1. Split cameras across controllers when two or more run at once. Two sets at about 111 MB/s total roughly 221 MB/s and fit one 5 Gbps controller with margin; four sets at roughly 442 MB/s do not. The enumeration-side checklist lives in multiple depth cameras on one host.
  2. Soak-test for ten minutes: configured fps sustained, no control-transfer error lines, negotiated USB type unchanged from start to finish.

If errors persist on a genuine SuperSpeed link with a budget that fits, the remaining suspects are power and CPU — the next section.

When the budget fits and it still drops

Three causes survive a correct budget. Power delivery at the connector: a loose lock, a cold joint or a cable drooping under vibration resets the device intermittently. Thermal throttling: an embedded host that heats mid-soak slows every subsystem, USB included, and a stream set that ran at bench temperature fails on a warm line. Software updates: a camera firmware and SDK pair that no longer aligns produces control-transfer noise of its own — the firmware and SDK alignment case is that class of fault. Virtual machines sit in the same bucket, because a VM's virtual controller adds its own pacing; the color stream timeout in a VM shows that ceiling from the other side.

Prevention checklist

Before install:

  • Compute the budget for the exact stream set and write it on the station drawing; redo it whenever any width, height, fps or format changes.
  • Give each camera a controller: above two devices, one camera per controller, powered hubs only.
  • Run cables rated USB 3.x for their length, strain-relieved and routed away from motor and drive cables.

At commissioning:

  • Read the negotiated USB type from every port the system will use, not only the bench port.
  • Soak ten minutes at configured fps with error logging on, and note sustained fps next to configured fps.

On the line:

  • Re-check the budget after every firmware, SDK or host-image update.

Size the link first, then buy to the arithmetic. The 3D sensors category holds the depth cameras, the camera cables category lists USB and Ethernet runs by length and flex rating, and the camera finder filters by interface and resolution. Start a full station from the configurator, and if the numbers still fight you, bring the stream table to the contact page — we will check the budget with you.

Questions

How much USB bandwidth does an 848 × 480 depth stream at 30 fps use?

In Z16 it is 848 × 480 px × 2 bytes × 30 fps = 24.4 MB/s. In Y8 mono it halves to 12.2 MB/s, and in Y16 it doubles to 48.8 MB/s: the pixel format moves the number as much as resolution or frame rate does. Add the color stream on top before comparing with a link, because USB 2.0's 60 MB/s line rate delivers only about 35-40 MB/s in practice.

Why does a depth camera enumerate but drop as soon as streaming starts?

Enumeration and control exchanges move trivial amounts of data, so any link that is electrically alive passes them. Streaming then claims bulk bandwidth continuously at the configured frame rate. A USB 2.0 hop, an exhausted controller or a sagging supply starves the endpoints, the stack resets the device, it re-enumerates, and the cycle repeats. Read the negotiated USB type from the device info first: a 2.x report explains the drop with no further diagnosis needed.

Does halving resolution or halving frame rate save the same bandwidth?

Yes. Bandwidth scales linearly with width, height, frame rate and bytes per pixel alike, so halving any one halves the MB/s. Choose by what the application loses: cutting frame rate keeps spatial detail for measurement and costs latency; cutting resolution keeps temporal response and costs accuracy. At 640 × 480 px in Z16, depth costs 55.3 MB/s at 90 fps and 27.6 MB/s at 45 fps.

Can two multi-stream depth cameras share one USB controller?

Sum both budgets and compare with about 400 MB/s of usable capacity on a 5 Gbps controller. Two cameras at roughly 111 MB/s each total about 221 MB/s and fit with margin; four total about 442 MB/s and do not. A hub in between re-shares the budget: two cameras behind one USB 2.0 hub segment share 35-40 MB/s between them, not each.

What do the libusb errors 'No data available' and 'No such device' mean?

'No data available' means the host asked the device for data and nothing was ready at the endpoint — typical when the stream set is choking the link or the driver keeps re-requesting a configuration the device refused. 'No such device' means the camera has detached from the bus entirely; expect the driver to re-enumerate it. Chase bandwidth and power first: these errors follow the starvation rather than naming its cause.