I develop Linux kernel drivers, microcontroller firmware and SIMD-optimized code for ARM platforms, with a specialty in real-time video processing.
For hardware and FPGA companies, and for Linux consultancies looking for a subcontractor. Fixed price per deliverable, against a performance target we agree on. Remote, white label on request.
Targets and tools
Embedded software on ARM, from the Linux kernel to the microcontroller. Most of my recent work has been in real-time video.
Drivers for custom hardware on ARM Linux boards, and the software that uses them.
Deterministic firmware for microcontrollers, from register-level drivers to the application.
Cortex-M MCU
Making C code meet its target on the real hardware: profiling, algorithmic work and SIMD.
#include <arm_neon.h>// RGB888 -> 8-bit luma, BT.601 weights 77/150/29 (sum 256).// 16 pixels per iteration; n is a multiple of 16.void rgb_to_y(const uint8_t *rgb, uint8_t *y, size_t n){ const uint8x8_t kr = vdup_n_u8(77); const uint8x8_t kg = vdup_n_u8(150); const uint8x8_t kb = vdup_n_u8(29); for (size_t i = 0; i < 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); vst1q_u8(y + i, vcombine_u8(vshrn_n_u16(lo, 8), vshrn_n_u16(hi, 8))); }}Illustrative excerpt: RGB888 to luma (BT.601), 16 pixels per iteration.
My specialty: pipelines that hold a frame rate and a latency budget, from capture to output.
fps · latency
Focused, well-scoped projects close to proven expertise, each priced as a deliverable.
We define the deliverable and a measurable objective together: throughput, latency, frame rate or footprint, on your target.
You receive a fixed price for the deliverable. No daily rate, no open-ended billing.
The code is delivered with measured results against the agreed objective.
Selected past work, described by what it does and how fast it runs.
1280 × 1024 @ 60 fps
SXGA, sustained
A complete video processing pipeline written from scratch in ARM NEON, sustaining SXGA at 60 frames per second on a Raspberry Pi 4.
< 1 frame
end-to-end latency*
A portable video processing framework for MCUs, handling several resolutions up to SXGA at 60 fps. Every processing algorithm exists as a generic C reference and as SIMD-optimized versions for two ARM cores.
* Depends on the number of enabled processing stages.
V4L2
written from scratch
A V4L2 capture driver written from scratch for a Raspberry Pi board.
I’m François Descamps. I came to software through electronics, and I still work where the two meet: drivers, firmware and optimized code that has to hold its timing on real hardware.
I also have earlier freelance experience: in 2018–2019 I built a connected radio prototype on Raspberry Pi as an independent embedded engineer, from the Linux setup and the audio code in C down to the circuit board.
Two-year French higher technician diploma.
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 the custom PCB in KiCad, from schematics and routing to soldering and debugging.
Software engineering, with a lot of C.
Engineering degree in embedded electronic systems, in parallel with École 42, as a work-study programme at Thales on embedded topics.
Embedded software for real-time video: NEON, Helium and Cortex-M DSP pipelines, V4L2 capture driver.
The quickest way to start is an email describing your target.
Useful to include
Hello François,
Target platform / core:
What needs to be built:
Performance objective:
Deadline: