olivier

hello , i s there any tuto to convert a yolo model to .bin ?

Hi Marcelo,
Thanks a lot for the detailed and precise explanation - this is extremely helpful.
I
Key points we have validated:
UVC MJPEG input
Since standard UVC drivers do not export DMABUF, we will manually copy the bitstream.
We will allocate physically contiguous memory using HB_SYS_Alloc, use the virtual address for memcpy, and pass the physical address to HB_VDEC_SendStream.

Hardware decoding
We will use HB_VDEC_SendStream with VIDEO_STREAM_S, using the physical address obtained from HB_SYS_Alloc.

VPS usage
We will always use the Decode :rightwards_arrow: VPS :rightwards_arrow: BPU pipeline.

We still have a few clarification questions to make sure we fully follow best practices on X5:

1) BPU scheduling in multi-camera scenarios
For multiple parallel video pipelines feeding the BPU, is the intended approach to use a single shared BPU context with a user-level scheduler (round-robin or priority-based)?
Or are there advantages to maintaining per-pipeline BPU contexts?
We are currently leaning toward a centralized user-level scheduler with frame-drop policies to avoid backlog.

2) Recommended buffer pool sizing
Is there a recommended number of pre-allocated HB_SYS_Alloc buffers per camera (for decode input and VPS output) to avoid stalls while keeping memory usage bounded?
Any guidance on typical pool sizes used in reference designs?

3)VPS multi-output usage
Is it considered best practice to use VPS to generate multiple outputs (for example one resized stream for BPU inference and another for display or streaming), or should VPS be kept strictly limited to the inference path?
Aside from these points, everything is now very clear, and we are confident moving forward with the SP Multimedia + BPU APIs in C.

Thanks again for the support and for the quality of the documentation and samples - they make building a product-grade pipeline on RDK X5 much easier.

Best regards,
Olivier

Thanks a lot for the detailed answer, it's very helpful
It confirms several key points for us, especially:
MJPEG/JPEG hardware decoding support on RDK X5
NV12 being the optimal internal format
and the practical limitation of DMABUF with standard UVC drivers.
We did look at TROS and we really like ROS in general. For robotic systems and rapid prototyping, it's clearly a great and powerfull solution and pôwerfull.
For this specific project though (multi-camera edge vision, always-on appliance, tight control over latency and resources), we plan to implement a standalone C/C++ pipeline directly on top of the SP multimedia APIs and BPU inference, without ROS. This gives us finer control over scheduling, memory usage, and performance.
That said, TROS is still very valuable for us as a reference implementation, especially for understanding the recommended UVC :rightwards_arrow: HW decode :rightwards_arrow: NV12 :rightwards_arrow: YOLO workflow. We may even prototype certain parts (like UVC capture) with TROS to validate behavior, then move to a lower-level implementation.
If you don't mind, we have a few follow-up questions to make sure we align with best practices on RDK X5:
For USB UVC MJPEG input (when DMABUF export is not available), is there a recommended method to copy the bitstream into HW-accessible memory (ION / media buffer) before feeding the SP decoder?
Is there any reference sample that shows the officially recommended buffer allocation + memcpy path?
After MJPEG HW decode (NV12 output), is it recommended to always pass the frames through VPS/VSE for resize/CSC before BPU, or can the decoder output be fed directly to the BPU if the resolution already matches the model input?
In multi-camera scenarios, is there any recommended practice for BPU job scheduling (single shared context vs per-pipeline contexts), or is a user-level scheduler the intended approach?
Thanks again for the guidance and the links - they are very useful for building an efficient and well-aligned pipeline on RDK X5.

Hello , im on rdk x5, I want to run YOLO inference from a USB UVC camera (OV5693, MJPEG 1080p30).
Target pipeline: UVC MJPEG :rightwards_arrow: HW JPEG decode :rightwards_arrow: VPS/VSE :rightwards_arrow: NPU (YOLO), with minimal CPU copies.

Questions:
- Is HW JPEG/MJPEG decode supported via hb_mm_mc/hbn?
- Can UVC DMABUF (VIDIOC_EXPBUF) be imported directly into codec/VPS, or is MMAP+copy required?
- Which sample is the best reference for USB camera :rightwards_arrow: inference?
- Recommended input format for YOLO (NV12 vs RGB)?

Thanks!

hello the d robotix site is down ? imlpossible to acces to the docs