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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include "Cam.hpp"
#include <libcamera/libcamera.h>
#include <format>
using namespace libcamera;
using namespace std;
HsLogger g_logger;
HsCallback g_callback;
unique_ptr<CameraManager> g_manager;
shared_ptr<Camera> g_camera;
unique_ptr<CameraConfiguration> g_config;
unique_ptr<FrameBufferAllocator> g_allocator;
unique_ptr<Request> g_request;
template<class... Args>
void
logMsg(Severity severity, const format_string<Args...> fmt, const Args &...args)
{
g_logger(severity, vformat(fmt.get(), make_format_args(args...)).c_str());
}
void
request_complete(Request *request)
{
int sequence = request->buffers().begin()->second->metadata().sequence;
logMsg(Trace, "Completed request #{}", sequence);
g_callback();
}
extern "C" void
register_logger(HsLogger hs_logger)
{
g_logger = hs_logger;
logMsg(Info, "Registered FFI logger");
}
extern "C" void
register_callback(HsCallback hs_callback)
{
g_callback = hs_callback;
logMsg(Info, "Registered FFI callback");
}
extern "C" void
start_camera_manager()
{
logMsg(Info, "Starting camera manager");
g_manager = make_unique<CameraManager>();
g_manager->start();
}
extern "C" void
stop_camera_manager()
{
logMsg(Info, "Stopping camera manager");
g_manager->stop();
}
extern "C" void
acquire_camera()
{
logMsg(Info, "Acquiring camera");
g_camera = g_manager->cameras()[0];
g_camera->acquire();
logMsg(Info, "Acquired camera: {}", g_camera->id());
}
extern "C" void
release_camera()
{
logMsg(Info, "Releasing camera");
g_camera->release();
g_camera.reset();
}
extern "C" void
allocate_frame_buffer()
{
logMsg(Info, "Generating camera configuration");
g_config = g_camera->generateConfiguration({ StreamRole::StillCapture });
g_config->at(0).size.width = FRAME_WIDTH;
g_config->at(0).size.height = FRAME_HEIGHT;
g_config->at(0).pixelFormat = formats::RGB888;
logMsg(Info, "Generated camera configuration: {}", g_config->at(0).toString());
g_camera->configure(g_config.get());
logMsg(Info, "Generating frame buffer allocator");
g_allocator = make_unique<FrameBufferAllocator>(g_camera);
g_allocator->allocate(g_config->at(0).stream());
logMsg(Info, "Registering request complete callback");
g_camera->requestCompleted.connect(request_complete);
}
extern "C" void
free_frame_buffer()
{
logMsg(Info, "Freeing frame buffer allocator");
g_allocator->free(g_config->at(0).stream());
g_allocator.reset();
}
extern "C" void
start_camera()
{
logMsg(Info, "Starting camera");
g_camera->start();
}
extern "C" void
stop_camera()
{
logMsg(Info, "Stopping camera");
g_camera->stop();
}
extern "C" void
create_request()
{
logMsg(Info, "Creating request");
g_request = g_camera->createRequest();
logMsg(Info, "Setting buffer for request");
Stream *stream = g_config->at(0).stream();
g_request->addBuffer(stream, g_allocator->buffers(stream)[0].get());
}
extern "C" int
get_dma_buffer_fd()
{
int fd = g_request->buffers().begin()->second->planes()[0].fd.get();
logMsg(Info, "DMA buffer available in FD {}", fd);
return fd;
}
extern "C" void
request_frame()
{
logMsg(Trace, "Requested frame");
g_request->reuse(Request::ReuseBuffers);
g_camera->queueRequest(g_request.get());
}
|
