uvc: add uncompressed NV12 streaming support

- Add runtime UVC format selection (mjpeg|uncompressed/nv12)
- Stream uncompressed NV12 frames from DepthAI with stride/plane-aware
repack
- Configure UVC configfs uncompressed descriptor as NV12 (uvc-gadget
submodule)
- Update app default startup format and README

Signed-off-by: Jure Rebernik <jure.rebernik@luxonis.com>

Author: Jure Rebernik

cpp/uvc/README.md

@@ -33,3 +33,10 @@ Running the example in standalone mode builds and deploys it as an OAK app so th
    ```
 
 `oakctl` uses the provided `oakapp.toml` to build the C++ project inside the Luxonis base container and deploy it to the device. Configuration tweaks such as changing the camera resolution or registering more topics should be done in `src/uvc_example.cpp`, then re-run `oakctl app run ./cpp/uvc`.
+
+### Video format selection
+
+The example supports two UVC stream formats controlled by `UVC_FORMAT` environment variable:
+
+- `nv12` / `uncompressed` (default): Uses DepthAI `NV12` output and exposes UVC uncompressed NV12 format.
+- `mjpeg`: Uses `VideoEncoder` and exposes UVC MJPEG format.

cpp/uvc/oakapp.toml

@@ -8,7 +8,7 @@ identifier = "com.example.streaming.uvc"
 app_version = "3.0.0"
 
 # Command to run when the container starts
-entrypoint = ["bash", "-c", "/app/uvc-start.sh start"]
+entrypoint = ["bash", "-c", "export UVC_FORMAT=nv12 && /app/uvc-start.sh start"]
 
 # Here is the place where you can install all the dependencies that are needed at run-time
 prepare_container = [

cpp/uvc/src/uvc_example.cpp

@@ -6,12 +6,18 @@
  */
 
 #include <atomic>
+#include <algorithm>
+#include <cstdlib>
 #include <csignal>
+#include <cctype>
 #include <cstring>
 #include <iostream>
+#include <string>
+#include <vector>
 
 #include "depthai/depthai.hpp"
 #include "depthai/pipeline/MessageQueue.hpp"
+#include "depthai/pipeline/datatype/Buffer.hpp"
 #include "depthai/pipeline/datatype/ImgFrame.hpp"
 #include "uvc_example.hpp"
 
@@ -35,6 +41,28 @@ std::atomic<bool> quitEvent(false);
 std::shared_ptr<dai::InputQueue> inputQueue{nullptr};
 std::shared_ptr<dai::MessageQueue> outputQueue;
 
+enum class StreamFormat {
+    MJPEG,
+    UNCOMPRESSED,
+};
+
+static StreamFormat gStreamFormat = StreamFormat::UNCOMPRESSED;
+static std::vector<uint8_t> gNv12Buffer;
+
+static StreamFormat parseStreamFormat() {
+    const char* format = std::getenv("UVC_FORMAT");
+    if(format == nullptr) return StreamFormat::UNCOMPRESSED;
+
+    std::string formatStr(format);
+    std::transform(formatStr.begin(), formatStr.end(), formatStr.begin(), [](unsigned char c) { return std::tolower(c); });
+
+    if(formatStr == "mjpeg") return StreamFormat::MJPEG;
+    if(formatStr == "uncompressed" || formatStr == "nv12") return StreamFormat::UNCOMPRESSED;
+
+    std::cerr << "Unknown UVC_FORMAT=\"" << formatStr << "\", defaulting to uncompressed NV12." << std::endl;
+    return StreamFormat::UNCOMPRESSED;
+}
+
 /* Necessary for and only used by signal handler. */
 static struct events *sigint_events;
 
@@ -48,22 +76,64 @@ void signalHandler(int signum) {
 
 extern "C" void depthai_uvc_get_buffer(struct video_source *s, struct video_buffer *buf) {
 	unsigned int frame_size, size;
-    uint8_t *f;
+    const uint8_t *f;
 
     if(quitEvent) {
         std::cout << "depthai_uvc_get_buffer(): Stopping capture due to quit event." << std::endl;
         return;
     }      
 
-    auto frame = outputQueue->get<dai::ImgFrame>();
-    if(frame == nullptr) {
-        std::cerr << "depthai_uvc_get_buffer(): No frame available." << std::endl;
-        return;
+    if(gStreamFormat == StreamFormat::MJPEG) {
+        auto frame = outputQueue->get<dai::Buffer>();
+        if(frame == nullptr || frame->getData().empty()) {
+            std::cerr << "depthai_uvc_get_buffer(): No MJPEG frame available." << std::endl;
+            return;
+        }
+        f = frame->getData().data();
+        frame_size = frame->getData().size();
+    } else {
+        auto frame = outputQueue->get<dai::ImgFrame>();
+        if(frame == nullptr) {
+            std::cerr << "depthai_uvc_get_buffer(): No uncompressed frame available." << std::endl;
+            return;
+        }
+        if(frame->getType() != dai::ImgFrame::Type::NV12) {
+            std::cerr << "depthai_uvc_get_buffer(): Unexpected frame type for uncompressed mode: " << static_cast<int>(frame->getType()) << std::endl;
+            return;
+        }
+
+        const auto width = frame->getWidth();
+        const auto height = frame->getHeight();
+        const auto stride = frame->getStride();
+        const auto uvPlaneOffset = frame->getPlaneStride(0);
+        const auto compactNv12FrameSize = (width * height * 3) / 2;
+        const auto expectedSrcBytes = uvPlaneOffset + (stride * (height / 2));
+        const auto& data = frame->getData();
+
+        if(data.size() < expectedSrcBytes) {
+            std::cerr << "depthai_uvc_get_buffer(): NV12 frame smaller than expected: have "
+                      << data.size() << " need " << expectedSrcBytes << std::endl;
+            return;
+        }
+
+        gNv12Buffer.resize(compactNv12FrameSize);
+        const auto* src = data.data();
+        auto* dst = gNv12Buffer.data();
+
+        for(uint32_t y = 0; y < height; ++y) {
+            memcpy(dst + (y * width), src + (y * stride), width);
+        }
+
+        const auto* uvSrc = src + uvPlaneOffset;
+        auto* uvDst = dst + (width * height);
+        for(uint32_t y = 0; y < height / 2; ++y) {
+            memcpy(uvDst + (y * width), uvSrc + (y * stride), width);
+        }
+
+        f = gNv12Buffer.data();
+        frame_size = static_cast<unsigned int>(gNv12Buffer.size());
     }
 
-    f = frame->getData().data();
-    frame_size = frame->getData().size();
-
 	size = std::min(frame_size, buf->size);
 	memcpy(buf->mem, f, size);
 	buf->bytesused = size;
@@ -90,6 +160,8 @@ int main() {
     struct video_source* src;
     struct uvc_stream* stream;
 
+    gStreamFormat = parseStreamFormat();
+
     depthai_uvc_register_get_buffer(depthai_uvc_get_buffer);
 
     fc = configfs_parse_uvc_function("uvc.0");
@@ -141,13 +213,20 @@ int main() {
     // Create nodes
     auto camRgb = pipeline.create<dai::node::Camera>()->build(socket);
     inputQueue  = camRgb->inputControl.createInputQueue();
-    auto output = camRgb->requestOutput(std::make_pair(1920, 1080), dai::ImgFrame::Type::NV12);
-
-    // Create video encoder node
-    auto encoded = pipeline.create<dai::node::VideoEncoder>();
-    encoded->setDefaultProfilePreset(30, dai::VideoEncoderProperties::Profile::MJPEG);
-    output->link(encoded->input);
-    outputQueue = encoded->bitstream.createOutputQueue(1, false);
+    constexpr uint32_t width = 1920;
+    constexpr uint32_t height = 1080;
+    auto output = camRgb->requestOutput(std::make_pair(width, height), dai::ImgFrame::Type::NV12);
+
+    if(gStreamFormat == StreamFormat::MJPEG) {
+        auto encoded = pipeline.create<dai::node::VideoEncoder>();
+        encoded->setDefaultProfilePreset(30, dai::VideoEncoderProperties::Profile::MJPEG);
+        output->link(encoded->input);
+        outputQueue = encoded->bitstream.createOutputQueue(1, false);
+        std::cout << "Configured UVC stream format: MJPEG" << std::endl;
+    } else {
+        outputQueue = output->createOutputQueue(1, false);
+        std::cout << "Configured UVC stream format: uncompressed NV12" << std::endl;
+    }
 
     // Start pipeline
     pipeline.start();

cpp/uvc/uvc-gadget

@@ -25,11 +25,14 @@ fi
 MANUF="Luxonis"
 PRODUCT="Luxonis UVC Camera"
 UDC=$(ls /sys/class/udc | head -n1) # will identify the 'first' UDC
+: "${UVC_FORMAT:=uncompressed}"
+UVC_FORMAT=$(echo "$UVC_FORMAT" | tr '[:upper:]' '[:lower:]')
 
 log "=== Detecting platform:"
 log "    product : $PRODUCT"
 log "    udc     : $UDC"
 log "    serial  : $SERIAL"
+log "    format  : $UVC_FORMAT"
 
 remove_uvc_gadget() {
     if [ ! -d /sys/kernel/config/usb_gadget/g1/functions/uvc.0 ]; then
@@ -101,6 +104,20 @@ create_frame() {
 EOF
 }
 
+configure_uncompressed_nv12_descriptor() {
+    FUNCTION=$1
+    NAME=$2
+
+    FRAME_DIR="functions/$FUNCTION/streaming/uncompressed/$NAME/1080p"
+    FORMAT_DIR="functions/$FUNCTION/streaming/uncompressed/$NAME"
+
+    # NV12 is 12bpp (4:2:0), frame size is width * height * 3 / 2.
+    echo 12 > "$FORMAT_DIR/bBitsPerPixel"
+    echo $(( 1920 * 1080 * 3 / 2 )) > "$FRAME_DIR/dwMaxVideoFrameBufferSize"
+    # UVC GUID for NV12: 4e 56 31 32 00 00 10 00 80 00 00 aa 00 38 9b 71
+    echo -ne '\x4e\x56\x31\x32\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71' > "$FORMAT_DIR/guidFormat"
+}
+
 create_uvc() {
     # Example usage:
     #   create_uvc <target config> <function name>
@@ -113,17 +130,20 @@ create_uvc() {
     pushd "$GADGET/g1" >/dev/null
     mkdir "functions/$FUNCTION"
 
-    # create_frame "$FUNCTION" 640 360 uncompressed u
-    # create_frame "$FUNCTION" 1280 720 uncompressed u
-    # create_frame "$FUNCTION" 320 180 uncompressed u
-    create_frame "$FUNCTION" 1920 1080 mjpeg m
-    # create_frame "$FUNCTION" 640 480 mjpeg m
-    # create_frame "$FUNCTION" 640 360 mjpeg m
+    if [ "$UVC_FORMAT" = "mjpeg" ]; then
+        create_frame "$FUNCTION" 1920 1080 mjpeg m
+    else
+        create_frame "$FUNCTION" 1920 1080 uncompressed u
+        configure_uncompressed_nv12_descriptor "$FUNCTION" "u"
+    fi
 
     mkdir "functions/$FUNCTION/streaming/header/h"
     cd "functions/$FUNCTION/streaming/header/h"
-    # ln -s ../../uncompressed/u
-    ln -s ../../mjpeg/m
+    if [ "$UVC_FORMAT" = "mjpeg" ]; then
+        ln -s ../../mjpeg/m
+    else
+        ln -s ../../uncompressed/u
+    fi
     cd ../../class/fs
     ln -s ../../header/h
     cd ../../class/hs