IMX704 Camera Library

English | 简体中文

This repository provides a C++17 processing and capture library for IMX704 dToF cameras with optional Python bindings.

The public C++ API uses the arducam::depthsense namespace. Live camera discovery and capture use the Linux media-controller and V4L2 interfaces. The current hardware pipeline implementation targets NVIDIA Jetson systems.

Features

• IMX704 camera discovery and control
• V4L2 image capture
• Raw image decoding
• Point cloud, radial depth, noise, peak-height, histogram, and PDC output
• Single-depth and dual-depth processing
• Offline camera and custom-stream support
• Optional Python bindings built with pybind11

Supported environment

• Linux
• CMake 3.18.4 or later
• A compiler with C++17 support (GCC or Clang)
• NVIDIA Jetson/aarch64 for live V4L2 camera capture
• Python 3 and pybind11 when Python bindings are enabled

The core processing sources can be compiled on other Linux architectures, but WITH_V4L2 is enabled automatically only when CMake detects aarch64.

Current limitations

• Embedded-data capture and processing are not currently supported.

Repository layout

.
├── CMakeLists.txt
├── cmake/                         # Platform and compiler configuration
├── lib/
│   ├── include/imx704_camera/     # Public C++ headers
│   ├── src/
│   │   ├── imx704_camera/         # C++ implementation and private headers
│   │   │   ├── pipeline/          # Generic and Jetson media pipelines
│   │   │   ├── spl/               # Raw decoding and depth processing
│   │   │   └── v4l2/              # V4L2 stream implementation
│   │   └── python/                # Python wrapper and pybind11 module
└── scripts/
    ├── build_lib.sh
    ├── create_imx704_lib_venv_jetson.sh
    └── pip_requirements.txt

Build the C++ library

Install the basic build tools:

sudo apt install build-essential g++ cmake

Run the build helper from the repository root:

./scripts/build_lib.sh

The script uses GCC and a Release build by default. Useful options are:

--build-type=Release|Debug|asan|lsan|tsan|msan|ubsan
--clang
-py, --with-pybind11

For example, to make a Debug build with Clang:

./scripts/build_lib.sh --clang --build-type=Debug

Build files are written below build/. Installed artifacts are written to a platform-specific directory below dist/.

Build the Python bindings on Jetson

Create the Python environment:

./scripts/create_imx704_lib_venv_jetson.sh
source venv/imx704_lib_jetson/bin/activate

Then build with pybind11 enabled:

./scripts/build_lib.sh --with-pybind11

The Python module and imx704_processor.py are installed in the platform-specific dist/<platform>/lib/ directory.

Build release packages

Install the Python packaging dependencies or activate the project virtual environment:

python3 -m pip install -r scripts/pip_requirements.txt

Build both the Debian development package and Python wheel:

./scripts/build_packages.sh

Build only one package type when needed:

./scripts/build_packages.sh --deb-only
./scripts/build_packages.sh --wheel-only

The script builds packages for the current CPU architecture and Python interpreter. Run it on the target Jetson/Python environment to produce Jetson release artifacts.

All packages are written to dist/packages/ inside this repository:

dist/packages/
├── libarducam-imx704-dev_<version>_<architecture>.deb
└── arducam_imx704-<version>-<python>-<abi>-<platform>.whl

The Debian package contains the static C++ library, public headers, and license. The wheel contains imx704_library_bindings and imx704_processor.py. The build script never copies artifacts to the parent directory.

Use ./scripts/build_packages.sh --help for all options. The release version must match in CMakeLists.txt and pyproject.toml; the script validates this before building.

Build Jetson/aarch64 packages with Docker

An x86_64 development host can produce an arm64 Debian package and CPython 3.8 through 3.14 wheels for Jetson systems in arm64 containers. Docker Buildx and linux/arm64 container support are required.

./scripts/build_jetson_aarch64_docker.sh

Use --deb-only or --wheel-only to build one package type. The resulting *_arm64.deb and cp38 through cp314 manylinux aarch64 wheels are written to dist/packages/. The Debian package uses an Ubuntu 22.04 builder, while wheels use a manylinux builder and separate per-Python build directories. The installation environment must provide a Python version matching one of the wheel tags.

Use the C++ API

Include the public headers from lib/include and use the arducam::depthsense namespace:

#include <imx704_camera/camera.h>
#include <imx704_camera/camera_manager.h>

using namespace arducam::depthsense;

camera_manager& manager = camera_manager::getInstance();
manager.init();

const auto cameras = manager.get_camera_list();
if (!cameras.empty()) {
    auto camera = manager.get_camera(cameras.front().id);
    camera->open(0x311C);
    camera->start();

    const frame_buffer& frame = camera->get_frame(100);

    camera->stop();
    camera->close();
}

See lib/include/imx704_camera for the public API.

License

See lib/LICENSE.