shiguredo_libcamera 2026.1.0

Rust bindings for libcamera
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#include "camera.h"
#include "internal.h"

#include <cstring>
#include <vector>

const char* lc_camera_id(const lc_camera_t* cam) {
  return cam->camera->id().c_str();
}

int lc_camera_acquire(lc_camera_t* cam) {
  return cam->camera->acquire();
}

int lc_camera_release(lc_camera_t* cam) {
  return cam->camera->release();
}

void lc_camera_release_ref(lc_camera_t* cam) {
  delete cam;
}

lc_camera_configuration_t* lc_camera_generate_configuration(
    lc_camera_t* cam,
    const lc_stream_role_t* roles,
    size_t roles_count) {
  std::vector<StreamRole> cpp_roles;
  cpp_roles.reserve(roles_count);
  for (size_t i = 0; i < roles_count; i++) {
    cpp_roles.push_back(to_stream_role(roles[i]));
  }
  auto config = cam->camera->generateConfiguration(cpp_roles);
  if (!config) {
    return nullptr;
  }
  auto lc_config = new lc_camera_configuration();
  lc_config->config = config.release();
  return lc_config;
}

int lc_camera_configure(lc_camera_t* cam, lc_camera_configuration_t* config) {
  return cam->camera->configure(config->config);
}

lc_request_t* lc_camera_create_request(lc_camera_t* cam, uint64_t cookie) {
  auto request = cam->camera->createRequest(cookie);
  if (!request) {
    return nullptr;
  }
  auto lc_req = new lc_request();
  lc_req->request = request.release();
  return lc_req;
}

int lc_camera_queue_request(lc_camera_t* cam, lc_request_t* request) {
  return cam->camera->queueRequest(request->request);
}

int lc_camera_start(lc_camera_t* cam) {
  return cam->camera->start();
}

int lc_camera_stop(lc_camera_t* cam) {
  return cam->camera->stop();
}

lc_control_list_t* lc_camera_properties(const lc_camera_t* cam) {
  auto lc_list = new lc_control_list();
  lc_list->list = const_cast<ControlList*>(&cam->camera->properties());
  lc_list->owned = false;
  return lc_list;
}

void lc_camera_connect_request_completed(lc_camera_t* cam,
                                         lc_request_completed_cb cb,
                                         void* user_data) {
  cam->callback.cb = cb;
  cam->callback.user_data = user_data;

  cam->camera->requestCompleted.connect(cam, [cam](Request* request) {
    if (cam->callback.cb) {
      /* Request をラップして渡す (所有権は渡さない) */
      lc_request_t lc_req;
      lc_req.request = request;
      cam->callback.cb(cam->callback.user_data, &lc_req);
    }
  });
}

void lc_camera_disconnect_request_completed(lc_camera_t* cam) {
  cam->camera->requestCompleted.disconnect(cam);
  cam->callback.cb = nullptr;
  cam->callback.user_data = nullptr;
}