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;
HsRequestCallback g_request_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
internal_request_callback(Request *request)
{
int sequence = request->buffers().begin()->second->metadata().sequence;
logMsg(Trace, "Completed request #{}", sequence);
g_request_callback();
}
extern "C" void
register_logger(HsLogger hs_logger)
{
g_logger = hs_logger;
logMsg(Info, "Registered FFI logger");
}
extern "C" void
register_request_callback(HsRequestCallback hs_request_callback)
{
g_request_callback = hs_request_callback;
logMsg(Info, "Registered FFI request 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::BGR888;
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 internal request callback");
g_camera->requestCompleted.connect(internal_request_callback);
}
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());
}
|
