feat: implement base libcamera bindings

.cargo/config

@@ -0,0 +1,2 @@
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"

.clang-format

@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+IndentWidth: 2

.clang-tidy

@@ -0,0 +1,13 @@
+Checks: "
+  -checks=clang-diagnostic-*,
+  clang-analyzer-*,
+  modernize-*,
+  cppcoreguidelines-*,
+  readability-*,
+  portability-*,
+  bugprone-*,
+  llvm-*,
+  cert-*,
+  hicpp-*,
+  -hicpp-exception-baseclass,
+  -modernize-use-trailing-return-type"

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+indent_style = space
+indent_size = 2

.gitignore

@@ -1,5 +1,10 @@
 .idea
 .vscode
+*.bak~
 
 /target
 Cargo.lock
+
+plane_*.bin
+image_*.png
+tmp.bgr

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "libcamera"]
+	path = libcamera
+	url = https://git.libcamera.org/libcamera/libcamera.git
+[submodule "gnutls"]
+	path = gnutls
+	url = https://gitlab.com/gnutls/gnutls.git

.rustfmt.toml

@@ -0,0 +1 @@
+tab_spaces = 2

Cargo.toml

@@ -1,11 +1,23 @@
 [package]
 name = "libcamera-rs"
+description = "Libcamera bindings for rust."
+authors = ["John Brandt <[email protected]>", "Ben Heard <[email protected]>"]
 version = "0.1.0"
 edition = "2021"
+license = "ISC"
 
 [dependencies]
 cxx = "1.0"
+thiserror = "1"
+log = "0.4"
+image = { version = "0.24", optional = true }
 
 [build-dependencies]
 cxx-build = "1.0"
 
+[dev-dependencies]
+lazy_static = "1"
+simplelog = "0.12"
+
+[features]
+default = [ "image" ]

build.rs

@@ -1,15 +1,39 @@
+const SOURCES: [&str; 15] = [
+  "libcamera-bridge/camera_manager.cpp",
+  "libcamera-bridge/camera.cpp",
+  "libcamera-bridge/camera_configuration.cpp",
+  "libcamera-bridge/stream_configuration.cpp",
+  "libcamera-bridge/pixel_format.cpp",
+  "libcamera-bridge/size.cpp",
+  "libcamera-bridge/stream.cpp",
+  "libcamera-bridge/frame_buffer_allocator.cpp",
+  "libcamera-bridge/frame_buffer.cpp",
+  "libcamera-bridge/frame_buffer_plane.cpp",
+  "libcamera-bridge/fd.cpp",
+  "libcamera-bridge/memory_buffer.cpp",
+  "libcamera-bridge/request.cpp",
+  "libcamera-bridge/control_id.cpp",
+  "libcamera-bridge/control_value.cpp",
+];
+
 fn main() {
-    cxx_build::bridge("src/bridge.rs")
-        .file("libcamera-bridge/core.cpp")
-        .flag_if_supported("-std=c++17")
-        .include("/usr/local/include/libcamera")
-        .compile("libcamera-bridge");
+  println!("cargo:rerun-if-changed=src/bridge.rs");
+  println!("cargo:rerun-if-changed=libcamera-bridge/core.hpp");
+  for source in &SOURCES {
+    println!("cargo:rerun-if-changed={source}");
+  }
 
-    println!("cargo:rerun-if-changed=src/bridge.rs");
-    println!("cargo:rerun-if-changed=libcamera-bridge/core.cpp");
-    println!("cargo:rerun-if-changed=libcamera-bridge/core.hpp");
+  cxx_build::bridge("src/bridge.rs")
+    .flag_if_supported("-std=c++17")
+    .warnings(true)
+    .extra_warnings(true)
+    .files(SOURCES)
+    .include("/usr/local/include/libcamera")
+    .include("libcamera/build/include/libcamera")
+    .compile("libcamera-bridge");
 
-    // link libcamera
-    println!("cargo:rustc-link-lib=dylib=camera");
-    println!("cargo:rustc-link-lib=dylib=camera-base");
+  // link libcamera
+  println!("cargo:rustc-link-search=/usr/local/lib");
+  println!("cargo:rustc-link-lib=dylib=camera");
+  println!("cargo:rustc-link-lib=dylib=camera-base");
 }

libcamera-bridge/camera.cpp

@@ -0,0 +1,184 @@
+#include "core.hpp"
+
+#include "libcamera-rs/src/bridge.rs.h"
+
+Camera::Camera(std::shared_ptr<libcamera::Camera> inner_)
+    : inner{std::move(inner_)} {
+  this->inner->bufferCompleted.connect(
+      this,
+      [&](libcamera::Request *request, libcamera::FrameBuffer *framebuffer) {
+        this->message_mutex.lock();
+        this->message_queue.push(CameraMessage{
+            .message_type = CameraMessageType::BufferComplete,
+            .request_cookie = request->cookie(),
+            .buffer_cookie = framebuffer->cookie(),
+        });
+        this->message_mutex.unlock();
+      });
+  this->inner->requestCompleted.connect(this, [&](libcamera::Request *request) {
+    this->message_mutex.lock();
+    this->message_queue.push(CameraMessage{
+        .message_type = CameraMessageType::RequestComplete,
+        .request_cookie = request->cookie(),
+        .buffer_cookie = 0,
+    });
+    this->message_mutex.unlock();
+  });
+}
+
+Camera::~Camera() {
+  this->inner->bufferCompleted.disconnect();
+  this->inner->requestCompleted.disconnect();
+}
+
+std::shared_ptr<libcamera::Camera> Camera::into_shared() {
+  VALIDATE_POINTERS()
+
+  return this->inner;
+}
+
+void Camera::acquire() {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->acquire();
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+void Camera::release() {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->release();
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+BindCameraConfiguration
+Camera::generate_configuration(rust::Slice<const libcamera::StreamRole> roles) {
+  VALIDATE_POINTERS()
+
+  std::vector<libcamera::StreamRole> roles_vec;
+  for (libcamera::StreamRole role : roles) {
+    roles_vec.push_back(role);
+  }
+
+  std::unique_ptr<libcamera::CameraConfiguration> conf =
+      this->inner->generateConfiguration(roles_vec);
+  if (!conf) {
+    throw error_from_code(ENODEV);
+  }
+
+  BindCameraConfiguration bind_conf{
+      .inner = std::make_unique<CameraConfiguration>(std::move(conf)),
+  };
+  return bind_conf;
+}
+
+void Camera::configure(CameraConfiguration &conf) {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->configure(conf.into_ptr());
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+BindRequest Camera::create_request(uint64_t cookie) {
+  VALIDATE_POINTERS()
+
+  std::unique_ptr<libcamera::Request> req = this->inner->createRequest(cookie);
+  if (!req) {
+    throw error_from_code(ENODEV);
+  }
+
+  BindRequest bind_req{
+      .inner = std::make_unique<Request>(std::move(req)),
+  };
+  return bind_req;
+}
+
+void Camera::queue_request(Request &req) {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->queueRequest(req.into_ptr());
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+void Camera::start() {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->start();
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+void Camera::stop() {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->stop();
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+rust::Vec<ControlPair> Camera::get_controls() const {
+  VALIDATE_POINTERS()
+
+  rust::Vec<ControlPair> controls;
+  for (const auto &[control, value] : this->inner->controls()) {
+    rust::Vec<BindControlValue> possible_values;
+    for (const auto &value : value.values()) {
+      BindControlValue bind_value{
+          .inner = std::make_unique<ControlValue>(value),
+      };
+      possible_values.push_back(std::move(bind_value));
+    }
+    ControlPair control_pair{
+        .id =
+            {
+                .inner = std::make_unique<ControlId>(control),
+            },
+        .min =
+            {
+                .inner = std::make_unique<ControlValue>(value.min()),
+            },
+        .max =
+            {
+                .inner = std::make_unique<ControlValue>(value.max()),
+            },
+        .value =
+            {
+                .inner = std::make_unique<ControlValue>(value.def()),
+            },
+        .valid_values = std::move(possible_values),
+    };
+    controls.push_back(std::move(control_pair));
+  }
+  return controls;
+}
+
+rust::Vec<CameraMessage> Camera::poll_events() {
+  rust::Vec<CameraMessage> messages;
+  while (!this->message_queue.empty()) {
+    messages.push_back(this->message_queue.front());
+    message_queue.pop();
+  }
+  return messages;
+}
+
+rust::Vec<CameraMessage>
+Camera::poll_events_with_cookie(uint64_t request_cookie) {
+  rust::Vec<CameraMessage> messages;
+  while (!this->message_queue.empty()) {
+    if (this->message_queue.front().request_cookie == request_cookie) {
+      messages.push_back(this->message_queue.front());
+      message_queue.pop();
+    }
+  }
+  return messages;
+}

libcamera-bridge/camera_configuration.cpp

@@ -0,0 +1,34 @@
+#include "core.hpp"
+
+#include "libcamera-rs/src/bridge.rs.h"
+
+libcamera::CameraConfiguration *CameraConfiguration::into_ptr() {
+  VALIDATE_POINTERS()
+
+  return this->inner.get();
+}
+
+size_t CameraConfiguration::size() const {
+  VALIDATE_POINTERS()
+
+  return this->inner->size();
+}
+
+BindStreamConfiguration CameraConfiguration::at(uint32_t idx) {
+  VALIDATE_POINTERS()
+
+  libcamera::StreamConfiguration *str = &this->inner->at(idx);
+  if (str == nullptr) {
+    throw std::runtime_error("No stream configuration with specified id.");
+  }
+  BindStreamConfiguration conf{
+      .inner = std::make_unique<StreamConfiguration>(str),
+  };
+  return conf;
+}
+
+CameraConfigurationStatus CameraConfiguration::validate() {
+  VALIDATE_POINTERS()
+
+  return this->inner->validate();
+}

libcamera-bridge/camera_manager.cpp

@@ -0,0 +1,53 @@
+#include "core.hpp"
+
+#include "libcamera-rs/src/bridge.rs.h"
+
+#include <bits/stdc++.h>
+
+BindCameraManager make_camera_manager() {
+  BindCameraManager manager{
+      .inner = std::make_unique<CameraManager>(
+          std::make_unique<libcamera::CameraManager>()),
+  };
+  return manager;
+}
+
+void CameraManager::start() {
+  VALIDATE_POINTERS()
+
+  int ret = this->inner->start();
+  if (ret < 0) {
+    throw error_from_code(-ret);
+  }
+}
+
+void CameraManager::stop() {
+  VALIDATE_POINTERS()
+
+  this->inner->stop();
+}
+
+rust::Vec<rust::String> CameraManager::get_camera_ids() const {
+  VALIDATE_POINTERS()
+
+  rust::Vec<rust::String> camera_ids;
+  for (std::shared_ptr<libcamera::Camera> cam : this->inner->cameras()) {
+    camera_ids.push_back(cam->id());
+  }
+  return camera_ids;
+}
+
+BindCamera CameraManager::get_camera_by_id(rust::Str rust_id) {
+  VALIDATE_POINTERS()
+
+  std::string cam_id = std::string(rust_id);
+  std::shared_ptr<libcamera::Camera> cam = this->inner->get(cam_id);
+  // C++ header mismatch will cause this to be completely silly
+  if (!cam || cam.use_count() > INT_MAX) {
+    throw error_from_code(ENODEV);
+  }
+  BindCamera bind_cam{
+      .inner = std::make_unique<Camera>(cam),
+  };
+  return bind_cam;
+}