USB Webcam Video on RZ/V2N

Capture video from a USB webcam on the SolidRun RZ/V2N HummingBoard IIoT and stream it to a remote PC over Ethernet, or display it locally on the 7" MIPI LCD — using GStreamer and VLC.

🎥 Streaming USB Webcam Video on RZ/V2N

A practical, end-to-end guide for capturing video from a USB camera attached to a SolidRun RZ/V2N HummingBoard IIoT and delivering the stream either to a remote PC over Ethernet or to the local 7" LCD panel — using GStreamer on the board and GStreamer or VLC on the receiver.

📋 Overview

Two delivery paths are supported. Pick the one that matches your use case:

The default codec is MJPEG over RTP — supported by both cameras and requiring no hardware codec on the board. An H.264 over RTP variant is also shown for the IMX678 module, which produces H.264 natively.

The IMX678 module's USB descriptor reads Camera Vendor USB3 openMV Camera — that is a firmware placeholder string. The hardware is the SF-SQ8A987-86 IMX678 module.

🛠️ Hardware

Component	Details
🟢 SoC / board	Renesas RZ/V2N — SolidRun HummingBoard IIoT
🖥️ Display	7" LCD, native 1024×600, MIPI-attached
🎦 Camera A	Logitech C922 Pro Stream Webcam · USB ID 046d:085c
🎦 Camera B	IMX678 USB3 Camera Module SF-SQ8A987-86 · USB ID 414c:6573
📡 Camera class	USB Video Class (UVC) — both cameras
🌐 Network	Onboard Ethernet on the carrier board

📦 Prerequisites

🟢 On the RZ/V2N (Yocto image)

The image must include:

• ✅ V4L2 kernel support (CONFIG_USB_VIDEO_CLASS=m — already in the BSP defconfig)
• ✅ v4l-utils — provides v4l2-ctl
• ✅ GStreamer core + good / bad / ugly plugin sets
• ✅ Weston (only for Option B — local LCD display)

Add to your image recipe or local.conf:

IMAGE_INSTALL:append = " gstreamer1.0 gstreamer1.0-plugins-base \
                         gstreamer1.0-plugins-good gstreamer1.0-plugins-bad \
                         gstreamer1.0-plugins-ugly v4l-utils"

💻 On the PC (receiver)

🐧 Ubuntu / Debian

sudo apt install gstreamer1.0-tools gstreamer1.0-plugins-base \
                 gstreamer1.0-plugins-good gstreamer1.0-plugins-bad \
                 gstreamer1.0-plugins-ugly gstreamer1.0-libav vlc

🐧 Fedora / RHEL

sudo dnf install gstreamer1 gstreamer1-plugins-base \
                 gstreamer1-plugins-good gstreamer1-plugins-bad-free \
                 gstreamer1-plugins-bad-free-gtk vlc

🪟 Windows

1. Download the GStreamer installer from the official GStreamer website.
2. Run it and select Complete Installation to include all base plugins.
3. Add the GStreamer bin\ directory to your PATH.
4. Allow inbound UDP on port 5000 through Windows Firewall and mark the connection as Private.
5. (Optional) Install VLC from videolan.org if you prefer the VLC receiver.

Firewall reminder — many "stream not appearing" reports on Windows are caused by Windows Defender Firewall silently dropping incoming UDP packets. Verify the network profile is Private and that GStreamer / VLC has firewall permission.

🔍 Detecting the camera

These steps are identical for both supported cameras.

Step 1 · Confirm USB enumeration

lsusb

Look for one of:

Bus 001 Device 004: ID 046d:085c Logitech, Inc. C922 Pro Stream Webcam
Bus 002 Device 005: ID 414c:6573 Camera Vendor USB3 openMV Camera   # = SF-SQ8A987-86

Step 2 · Load the UVC driver (if not auto-loaded)

modprobe uvcvideo
lsmod | grep uvcvideo

Expected:

uvcvideo              110592  0

udev autoloads uvcvideo on hotplug once the matching kernel modules are present in /lib/modules/$(uname -r)/. The manual modprobe is only needed for the first run or if udev autoloading is disabled.

Step 3 · Identify the V4L2 capture node

v4l2-ctl --list-devices
ls /dev/video*

When a single camera is plugged in, the capture node is typically /dev/video0.

The IMX678 module exposes a second node /dev/video1 for UVC metadata. Do not use it for video — it will return not a capture device with capability bits 0x4a00000. Use /dev/video0.

To identify the correct node when multiple V4L2 sources are present:

for d in /dev/video*; do
  echo "=== $d ==="
  v4l2-ctl -d "$d" --all | grep -E 'Card type|Device Caps' | head -3
done

The node whose Device Caps line includes the Video Capture flag is the right one.

Step 4 · List supported formats

v4l2-ctl -d /dev/video0 --list-formats-ext

🎦 Camera	Native formats	Useful resolutions
Logitech C922 Pro	MJPG, YUYV, (H.264 on some firmware)	640×480, 1280×720, 1920×1080 — all @ 30 fps
SF-SQ8A987-86 (IMX678)	MJPG, H.264, YUYV	640×480, 1280×720, 1920×1080, 3776×2120, 3840×2160 — all @ 30 fps

🌐 Option A — Stream over Ethernet to a remote PC

Architecture

How it works:

• The board captures MJPEG frames from /dev/video0.
• Frames are packetized into RTP (payload type 26 = JPEG) and sent over UDP to the PC on port 5000.
• The PC receives, depacketizes, decodes, and renders the stream.

Get the PC's IP address (ip a on Linux, ipconfig on Windows) — used as <PC_IP> in every sender command below.

Always start the receiver before the sender. UDP is connectionless; any packets the receiver isn't ready for are silently dropped.

📤 A.1 — Sender: Logitech C922 (MJPEG 1280×720 @ 30 fps)

🟢 On the RZ/V2N:

gst-launch-1.0 -v \
  v4l2src device=/dev/video0 ! \
  image/jpeg,width=1280,height=720,framerate=30/1 ! \
  rtpjpegpay ! \
  udpsink host=<PC_IP> port=5000 sync=false async=false

📤 A.2 — Sender: SF-SQ8A987-86 (MJPEG 1920×1080 @ 30 fps)

🟢 On the RZ/V2N:

gst-launch-1.0 -v \
  v4l2src device=/dev/video0 ! \
  image/jpeg,width=1920,height=1080,framerate=30/1 ! \
  rtpjpegpay ! \
  udpsink host=<PC_IP> port=5000 sync=false async=false

No local decode is performed for streaming. The board only captures + packetizes — the receiver does the heavy decoding. 1080p MJPEG over RTP runs comfortably on the board.

If the receiver PC or network struggles, drop the capture to 720p by changing 1920 / 1080 to 1280 / 720.

📤 A.3 — Sender: SF-SQ8A987-86 (H.264 1920×1080 @ 30 fps — lower bandwidth)

The IMX678 module produces H.264 natively. H.264 over RTP yields a much smaller stream than MJPEG and is the recommended path for wireless / constrained networks.

🟢 On the RZ/V2N:

gst-launch-1.0 -v \
  v4l2src device=/dev/video0 ! \
  video/x-h264,width=1920,height=1080,framerate=30/1 ! \
  h264parse config-interval=1 ! \
  rtph264pay pt=96 ! \
  udpsink host=<PC_IP> port=5000 sync=false async=false

The Logitech C922 also advertises H.264 on some firmware revisions, but support varies between units. Stay on MJPEG for the C922 unless v4l2-ctl --list-formats-ext confirms H.264 is present.

📥 A.4 — Receiver: GStreamer (MJPEG)

🐧 Linux

gst-launch-1.0 -v \
  udpsrc port=5000 caps="application/x-rtp,encoding-name=JPEG,payload=26" ! \
  rtpjpegdepay ! \
  jpegdec ! \
  videoconvert ! \
  autovideosink sync=false

🪟 Windows (PowerShell)

gst-launch-1.0 -v `
  udpsrc port=5000 caps="application/x-rtp,encoding-name=JPEG,payload=26" ! `
  rtpjpegdepay ! `
  jpegdec ! `
  videoconvert ! `
  autovideosink sync=false

📥 A.5 — Receiver: GStreamer (H.264)

💻 On the Linux PC:

gst-launch-1.0 -v \
  udpsrc port=5000 caps="application/x-rtp,encoding-name=H264,payload=96" ! \
  rtph264depay ! \
  avdec_h264 ! \
  videoconvert ! \
  autovideosink sync=false

🎬 A.6 — Receiver: VLC (via SDP file)

VLC needs a Session Description (SDP) file to know how to parse an RTP-over-UDP stream.

MJPEG SDP

camera.sdp

v=0
o=- 0 0 IN IP4 127.0.0.1
s=RZV2N USB Camera
c=IN IP4 0.0.0.0
t=0 0
m=video 5000 RTP/AVP 26
a=rtpmap:26 JPEG/90000

H.264 SDP

camera.sdp

v=0
o=- 0 0 IN IP4 127.0.0.1
s=RZV2N USB Camera
c=IN IP4 0.0.0.0
t=0 0
m=video 5000 RTP/AVP 96
a=rtpmap:96 H264/90000
a=fmtp:96 packetization-mode=1

Open the SDP in VLC:

vlc camera.sdp

Or from the VLC GUI: Media → Open File… and select camera.sdp.

Reduce VLC latency — VLC defaults to ~1 s of network caching for smoothness. To get closer to real-time, launch with:

vlc --network-caching=200 camera.sdp

🎬 A.7 — Receiver: VLC (direct RTP URL)

VLC can also open the stream directly without an SDP:

vlc rtp://@:5000

VLC cannot always auto-detect the JPEG payload format from the RTP stream alone. If the window stays black with rtp://@:5000, fall back to the SDP file method in §A.6.

🖥️ Option B — Display locally on the 7" LCD

This option renders the camera stream fullscreen on the 7" 1024×600 panel using Weston (the Wayland compositor included in the SolidRun image).

Architecture

🔧 B.1 · Set the Weston environment

GStreamer needs two environment variables to talk to Weston. Run these in any shell that will launch a GStreamer command:

export XDG_RUNTIME_DIR=/run/user/0
export WAYLAND_DISPLAY=wayland-1

Confirm Weston is running and the Wayland socket exists:

systemctl status weston
ls /run/user/0/wayland-*

Why wayland-1? SolidRun's Yocto image runs Weston as wayland-1 (not the default wayland-0). Verify with the ls command above — it will show the actual socket name.

🎥 B.2 · Local preview pipeline (works for both cameras)

🟢 On the RZ/V2N:

gst-launch-1.0 -v v4l2src device=/dev/video0 ! \
    image/jpeg,width=640,height=480,framerate=30/1 ! \
    jpegdec ! videoconvert ! \
    videoscale ! video/x-raw,width=1024,height=600 ! \
    waylandsink fullscreen=true

Both supported cameras are UVC-class — the v4l2src element does not need camera-specific configuration. Capture at 640×480, software-decode JPEG, software-scale to the panel's native 1024×600, then fullscreen via Weston.

Stop with Ctrl-C.

Verified output: Smooth 30 fps on the 1024×600 panel, no buffer drops, clean shutdown.

🚀 B.3 · Make the preview a one-shot script

/usr/local/bin/usb-camera-preview

#!/bin/sh
export XDG_RUNTIME_DIR=/run/user/0
export WAYLAND_DISPLAY=wayland-1
exec gst-launch-1.0 -v v4l2src device=/dev/video0 ! \
    image/jpeg,width=640,height=480,framerate=30/1 ! \
    jpegdec ! videoconvert ! \
    videoscale ! video/x-raw,width=1024,height=600 ! \
    waylandsink fullscreen=true

Install and run:

chmod +x /usr/local/bin/usb-camera-preview
usb-camera-preview

🔀 B.4 · Stream over Ethernet and preview locally at the same time

Use tee to duplicate the MJPEG stream — one branch goes to the network, the other is decoded locally for the panel:

🟢 On the RZ/V2N:

gst-launch-1.0 -v v4l2src device=/dev/video0 ! \
    image/jpeg,width=1280,height=720,framerate=30/1 ! \
    tee name=t \
      t. ! queue ! rtpjpegpay ! \
            udpsink host=<PC_IP> port=5000 sync=false async=false \
      t. ! queue ! jpegdec ! videoconvert ! \
            videoscale ! video/x-raw,width=1024,height=600 ! \
            waylandsink fullscreen=true

Combined load — the network branch is cheap (capture + packetize), but the local-preview branch still does software JPEG decode + scale. If you see slowdown on the panel, drop the capture resolution to 640×480.

📊 Performance notes

🌐 Network streaming

The board only does capture + RTP packetization for network streams — no local decode. The heavy lifting happens on the receiver PC, so the RZ/V2N's CPU stays mostly idle.

🎦 Camera	📐 Resolution	🧬 Codec	📡 Bitrate (approx)	🧠 RZ/V2N CPU	📝 Notes
Logitech C922	1280×720 @ 30	MJPEG	30–60 Mbps	Low	Default for C922
Logitech C922	1920×1080 @ 30	MJPEG	60–120 Mbps	Low	Works on wired LAN
SF-SQ8A987-86	1920×1080 @ 30	MJPEG	50–100 Mbps	Low	Native MJPEG
SF-SQ8A987-86	1920×1080 @ 30	H.264	5–15 Mbps	Low	Lowest bandwidth · best for Wi-Fi ⭐

🖥️ Local LCD preview

The host pipeline (software JPEG decode + software color convert + SHM copy to Weston) is what limits sustained display rate.

📐 Resolution	🎬 Behavior on 1024×600 panel
640×480 MJPEG	✅ Smooth 30 fps — recommended default
1280×720 MJPEG	🟡 Generally smooth, slightly higher CPU
1920×1080 MJPEG	🔴 Visibly slow (~10 fps) — CPU-bound

For ≥720p smooth on the LCD, two upstream improvements are needed (not in the default image):

1. Hardware H.264 decode (v4l2h264dec or the Renesas codec plugin) — drops decode CPU to near zero.
2. Weston dmabuf support — eliminates the per-frame SHM memcpy.

Neither is required for the 640×480 default path.

🔧 Troubleshooting

❌ modprobe: ERROR: could not insert 'uvcvideo': Exec format error

uvcvideo: version magic '6.1.141-cip43-XXXX-dirty' should be '6.1.141-cip43-YYYY-dirty'

Cause: the .ko was built against a different kernel-source state than the running Image.

Fix: rebuild kernel and modules in lockstep from the same source state:

make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- olddefconfig
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- -j$(nproc) Image modules dtbs

rm -rf /tmp/rzv2n-mods
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \
     INSTALL_MOD_PATH=/tmp/rzv2n-mods INSTALL_MOD_STRIP=1 modules_install

Copy both arch/arm64/boot/Image and /tmp/rzv2n-mods/lib/modules/<ver>/ to the board, then reboot.

Avoid this class of failure entirely by adding to the defconfig:

CONFIG_LOCALVERSION_AUTO=n
CONFIG_LOCALVERSION=""

❌ Stream is choppy · "A lot of buffers are being dropped"

Cause: the pipeline was launched without a caps filter, so v4l2src negotiated the camera's default (often 4K YUYV uncompressed at 30 fps — ~474 MB/s of raw video).

Fix: always pin format and resolution with image/jpeg,width=...,height=...,framerate=30/1 between v4l2src and the decoder.

⚠️ Could not bind to zwp_linux_dmabuf_v1

Cause: Weston in this image does not advertise the dmabuf protocol.

Effect: waylandsink falls back to SHM buffers — one extra memcpy per frame.

Verdict: safe to ignore at 640×480; becomes a measurable cost at 1080p+.

⚠️ uvcvideo: Non-zero status (-71) in video completion handler

A single occurrence at stream start is benign — the UVC alternate-setting switch as the camera negotiates its USB bandwidth allocation.

If the message repeats continuously during streaming, suspect:

• 🔌 Cable quality
• ⚡ Insufficient hub power (especially with USB3 cameras drawing >500 mA)
• 📡 USB signal integrity (long cables, passive hubs)

❌ Device '/dev/videoX' is not a capture device. Capabilities: 0x4a00000

Cause: targeting the UVC metadata node (typically /dev/video1 on the IMX678 module).

Capability bits 0x4a00000 = META_CAPTURE | STREAMING | EXT_PIX_FORMAT — note no VIDEO_CAPTURE (bit 0x1).

Fix: use /dev/video0 — the node whose Device Caps includes the Video Capture flag:

v4l2-ctl -d /dev/video0 --all | grep 'Device Caps'

❌ Receiver shows a black window — no video

Checklist:

• Receiver started before sender
• PC firewall allows inbound UDP on port 5000
• <PC_IP> is reachable from the board (ping <PC_IP> on the board)
• On Windows, network profile is set to Private
• For VLC, used the SDP file method (not the bare rtp:// URL)

⚠️ fpsdisplaysink reports impossibly low fps

Cause: fpsdisplaysink overrides its inner sink's sync=false back to sync=true, dropping late frames against the pipeline clock. The rendered fps it reports is sink-survival rate, not source delivery rate.

Fix — for an accurate source-rate measurement:

gst-launch-1.0 v4l2src device=/dev/video0 num-buffers=300 ! \
    image/jpeg,width=640,height=480,framerate=30/1 ! fakesink

Total time / 300 = actual source fps.

❌ Camera enumerates but no /dev/video* appears

dmesg | grep -iE 'uvc|usb 2-|usb 4-'

If dmesg shows new high-speed USB device but no follow-up idVendor= / Product= lines, the descriptor read failed.

This is a USB-host issue, not a driver issue. Suspect cable / hub / power.

🚀 Quick reference

🟢 On the RZ/V2N

Task	Command / Section
🔍 Detect camera	lsusb
📥 Load UVC driver	modprobe uvcvideo
📋 List V4L2 nodes	v4l2-ctl --list-devices
📐 List supported formats	v4l2-ctl -d /dev/video0 --list-formats-ext
📡 Stream MJPEG to PC (C922)	see §A.1
📡 Stream MJPEG to PC (IMX678)	see §A.2
📡 Stream H.264 to PC (IMX678)	see §A.3
🖥️ Show preview on 7" LCD	usb-camera-preview
🔀 Stream + local preview	see §B.4
⏹️ Stop preview	Ctrl-C

💻 On the PC

Task	Command / Section
📥 Receive MJPEG (Linux / Windows)	see §A.4
📥 Receive H.264 (Linux)	see §A.5
🎬 Receive via VLC (SDP file)	see §A.6 — vlc camera.sdp
🎬 Receive via VLC (direct URL)	see §A.7 — vlc rtp://@:5000

📚 See also — for a deeper dive into the IMX678 module on RZ/V2N (kernel module install, driver detection, format reference), see the companion document "USB Camera on RZ/V2N — IMX678 USB3 Module (SF-SQ8A987-86)".