# USB Webcam Video on RZ/V2N

## 🎥 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:

```mermaid
flowchart TD
    A["📦 USB Webcam<br/>Logitech C922 / IMX678"] -->|USB| B["🟢 RZ/V2N HummingBoard IIoT<br/>Yocto Linux"]
    B -->|"Option A — RTP/UDP over Ethernet"| C["💻 Remote PC<br/>GStreamer or VLC"]
    B -->|"Option B — Wayland"| D["🖥️ 7&quot; 1024×600 MIPI LCD"]
```

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.

{% hint style="info" %}
**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.
{% endhint %}

### 🛠️ 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`:

```bitbake
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)

{% tabs %}
{% tab title="🐧 Ubuntu / Debian" %}

```bash
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
```

{% endtab %}

{% tab title="🐧 Fedora / RHEL" %}

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

{% endtab %}

{% tab title="🪟 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.
   {% endtab %}
   {% endtabs %}

{% hint style="warning" %}
**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.
{% endhint %}

### 🔍 Detecting the camera

These steps are identical for both supported cameras.

#### Step 1 · Confirm USB enumeration

```bash
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)

```bash
modprobe uvcvideo
lsmod | grep uvcvideo
```

Expected:

```
uvcvideo              110592  0
```

{% hint style="info" %}
**`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.
{% endhint %}

#### Step 3 · Identify the V4L2 capture node

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

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

{% hint style="warning" %}
**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`.
{% endhint %}

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

```bash
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

```bash
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

```mermaid
flowchart LR
    subgraph BOARD["🟢 RZ/V2N Board"]
        direction TB
        Cam["🎦 USB Camera"] --> V[v4l2src]
        V --> J["image/jpeg caps"]
        J --> P[rtpjpegpay]
        P --> S["udpsink<br/>host=&lt;PC_IP&gt;<br/>port=5000"]
    end
    S -.->|"RTP/UDP :5000<br/>Ethernet"| US[udpsrc]
    subgraph PCS["💻 Remote PC"]
        direction TB
        US --> Dep[rtpjpegdepay]
        Dep --> Dec[jpegdec]
        Dec --> VC[videoconvert]
        VC --> Sink["autovideosink<br/>or VLC"]
    end
```

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.

{% hint style="warning" %}
**Always start the receiver before the sender.** UDP is connectionless; any packets the receiver isn't ready for are silently dropped.
{% endhint %}

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

🟢 **On the RZ/V2N:**

```bash
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:**

```bash
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
```

{% hint style="info" %}
**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`.
{% endhint %}

#### 📤 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:**

```bash
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
```

{% hint style="info" %}
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.
{% endhint %}

#### 📥 A.4 — Receiver: GStreamer (MJPEG)

{% tabs %}
{% tab title="🐧 Linux" %}

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

{% endtab %}

{% tab title="🪟 Windows (PowerShell)" %}

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

{% endtab %}
{% endtabs %}

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

💻 **On the Linux PC:**

```bash
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.

{% tabs %}
{% tab title="MJPEG SDP" %}
{% code title="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
```

{% endcode %}
{% endtab %}

{% tab title="H.264 SDP" %}
{% code title="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
```

{% endcode %}
{% endtab %}
{% endtabs %}

Open the SDP in VLC:

```bash
vlc camera.sdp
```

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

{% hint style="info" %}
**Reduce VLC latency** — VLC defaults to \~1 s of network caching for smoothness. To get closer to real-time, launch with:

```bash
vlc --network-caching=200 camera.sdp
```

{% endhint %}

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

VLC can also open the stream directly without an SDP:

```bash
vlc rtp://@:5000
```

{% hint style="warning" %}
**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.
{% endhint %}

### 🖥️ 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

```mermaid
flowchart LR
    Cam["🎦 USB Camera"] --> V[v4l2src]
    V --> J["image/jpeg caps"]
    J --> D[jpegdec]
    D --> VC[videoconvert]
    VC --> Sc["videoscale<br/>→ 1024×600"]
    Sc --> W["waylandsink<br/>fullscreen"]
    W --> LCD["🖥️ 7&quot; MIPI LCD<br/>1024 × 600"]
```

#### 🔧 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:**

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

Confirm Weston is running and the Wayland socket exists:

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

{% hint style="info" %}
**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.
{% endhint %}

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

🟢 **On the RZ/V2N:**

```bash
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`.

{% hint style="success" %}
**Verified output:** Smooth 30 fps on the 1024×600 panel, no buffer drops, clean shutdown.
{% endhint %}

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

{% code title="/usr/local/bin/usb-camera-preview" %}

```bash
#!/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
```

{% endcode %}

Install and run:

```bash
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:

```mermaid
flowchart LR
    Cam["🎦 USB Camera"] --> V[v4l2src]
    V --> J["image/jpeg caps"]
    J --> T{tee}
    T --> Q1[queue]
    Q1 --> Pay[rtpjpegpay]
    Pay --> US["udpsink → 💻 PC"]
    T --> Q2[queue]
    Q2 --> Dec[jpegdec]
    Dec --> VC[videoconvert]
    VC --> Sc["videoscale<br/>→ 1024×600"]
    Sc --> W["waylandsink<br/>🖥️ LCD"]
```

🟢 **On the RZ/V2N:**

```bash
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
```

{% hint style="warning" %}
**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.
{% endhint %}

### 📊 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    |

{% hint style="info" %}
**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.
{% endhint %}

### 🔧 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:

```bash
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.

{% hint style="info" %}
**Avoid this class of failure entirely** by adding to the defconfig:

```
CONFIG_LOCALVERSION_AUTO=n
CONFIG_LOCALVERSION=""
```

{% endhint %}

#### ❌ 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:

```bash
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:**

```bash
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

```bash
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` |

{% hint style="info" %}
📚 **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)"*.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dev.solid-run.com/renesas/rz-v2n/rz-v2n-other-articles/usb-webcam-video-on-rz-v2n.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.