Your FPGA or sensor delivers frames, but Linux can’t read them yet.
I write the V4L2 capture driver, the Device Tree binding and the userspace code on top.
Character, platform and V4L2 drivers, written from scratch or extended
Kernel–userspace interfaces: ioctl, sysfs, mmap
Userspace libraries, tools and GUIs on top of the driver
Reference work
V4L2
written from scratch
Linux capture driver
A V4L2 capture driver for a Raspberry Pi board.
Subsystem
Video4Linux2 (V4L2)
Platform
Raspberry Pi
Bare-metal firmware on Cortex-M
Your custom board needs bare-metal firmware.
I write the register-level drivers (DMA, interrupts, peripherals) and the application on top.
STM32 family and other Cortex-M microcontrollers
Hardware-specific code kept in one layer, so the rest carries over to another microcontroller
Reference work
< 0.5 frame
end-to-end latency
Real-time video framework for microcontrollers
A video processing framework for Cortex-M microcontrollers, handling several resolutions up to SXGA at 60 fps, ported to two cores.
Cortex-M55
Helium (MVE)
Cortex-M33
Armv8-M DSP instructions
Resolution
Up to 1280 × 1024 @ 60 fps
Performance optimization on ARM
Your processing misses its frame rate or cycle budget, on Cortex-A or Cortex-M.
I profile it and rewrite the hot stages in NEON, Helium or DSP instructions until it fits the budget.
ARM NEON on Cortex-A
Helium (MVE) and DSP instructions on Cortex-M
The plain C version stays in the code base, as a test reference and a fallback on other cores
Reference work
1280 × 1024 @ 60 fps
SXGA, sustained
Video processing pipeline in ARM NEON
A complete video processing pipeline written from scratch in ARM NEON, sustaining SXGA at 60 frames per second on a Raspberry Pi 4.
Target
Raspberry Pi 4 · Cortex-A72
Frame budget
16.7 ms
Throughput
78.6 Mpixel/s
rgb_to_y.cARM NEON · C99
#include <arm_neon.h>// RGB888 -> 8-bit luma: full-range BT.601 weights// 77/150/29 (sum 256), rounded. 16 pixels per NEON// iteration, then a plain C loop for the tail.voidrgb_to_y(constuint8_t *rgb, uint8_t *y, size_t n){constuint8x8_t kr = vdup_n_u8(77);constuint8x8_t kg = vdup_n_u8(150);constuint8x8_t kb = vdup_n_u8(29);size_t i = 0;for (; i + 16 <= n; i += 16) {// Load 16 pixels and de-interleave R, G, B.uint8x16x3_t px = vld3q_u8(rgb + 3 * i);uint16x8_t lo = vmull_u8(vget_low_u8(px.val[0]), kr); lo = vmlal_u8(lo, vget_low_u8(px.val[1]), kg); lo = vmlal_u8(lo, vget_low_u8(px.val[2]), kb);uint16x8_t hi = vmull_u8(vget_high_u8(px.val[0]), kr); hi = vmlal_u8(hi, vget_high_u8(px.val[1]), kg); hi = vmlal_u8(hi, vget_high_u8(px.val[2]), kb);// Rounding narrow: (sum + 128) >> 8.vst1q_u8(y + i, vcombine_u8(vrshrn_n_u16(lo, 8),vrshrn_n_u16(hi, 8))); }// Remaining pixels: same arithmetic in plain C.for (; i < n; i++) {constuint8_t *p = rgb + 3 * i;uint32_t s = 77 * p[0] + 150 * p[1] + 29 * p[2]; y[i] = (uint8_t)((s + 128) >> 8); }}
Illustrative excerpt: RGB888 to luma (BT.601, rounded), 16 pixels per iteration, plain C tail.
How it works
1
Scope and feasibility
We agree on the deliverable and the figure it must reach on your hardware: throughput, latency, frame rate or memory footprint. When that figure isn’t certain to be reachable, a short paid feasibility study comes first. Its cost is credited against the project, and if the study shows it can’t be done, we stop there and you keep the results.
2
Fixed quote
You receive a fixed price for the deliverable. No daily rate, no open-ended billing.
3
Delivery
You get the code with the figures measured on your hardware.
Terms of engagement
Typical duration
3 to 8 weeks
For most deliverables
Intellectual property
Transferred to you
Source code and IP, on final payment
Warranty
6 months
Bugs in the delivered code fixed free of charge
Confidentiality
NDA on request
Subcontracting
White label
Available for consultancies
Location
Fully remote
Background
I’m François Descamps. I came to software through electronics, and I still work where the two meet, on drivers, firmware and optimized code that has to hold its timing on real hardware.
Education and experience
BTS in electronics
Two-year French higher technician diploma.
Embedded systems engineer, freelance
Connected radio prototype on Raspberry Pi: radio receiver chips driven over I²C and I²S, audio streams in C with JACK, audio over Ethernet-over-USB, Debian setup and administration (networking, clustering), and a custom PCB designed in KiCad, then soldered and debugged by hand.
École 42
Software engineering, with a lot of C.
Mines Saint-Étienne
Engineering degree in embedded electronic systems, in parallel with École 42, as a work-study programme at Thales.
Real-time video processing on ARM
Since 2025
Contact
The quickest way to start is an email about your hardware and what it needs to do.