MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
SerialReader.cpp
Go to the documentation of this file.
1#include "SerialReader.hpp"
2
4
5namespace MayaFlux::Core {
6
7namespace P = Transitive::Protocol;
8
9namespace {
10
11 std::optional<InputValue> parse_numbers_of(P::Message frame, uint32_t id)
12 {
13 std::string text(P::as_text(frame));
14 std::ranges::replace_if(text, [](char c) { return c == ',' || c == ';'; }, ' ');
15
16 auto numbers = Reflect::parse_numbers<double>(text);
17 if (!numbers || numbers->empty()) {
18 return std::nullopt;
19 }
20 return InputValue::make_vector(std::move(*numbers), id, InputType::SERIAL);
21 }
22
23}
24
26 : m_id(id)
27 , m_spec(std::move(spec))
28 , m_link(link)
30{
31}
32
37
39{
40 const size_t limit = spec.message_limit;
41
42 switch (spec.framing) {
44 return Framer { std::in_place_type<P::LineFramer>, limit };
46 const auto terminator = spec.delimiter();
47 return Framer { std::in_place_type<P::DelimiterFramer>, std::span<const uint8_t> { terminator }, limit };
48 }
50 return Framer { std::in_place_type<P::CobsFramer>, limit };
52 return Framer { std::in_place_type<P::SlipFramer>, limit };
54 return Framer { std::in_place_type<P::IdleGapFramer>, std::chrono::duration_cast<std::chrono::microseconds>(spec.gap), limit };
56 break;
57 }
58 return Framer { std::in_place_type<P::RawChunkFramer> };
59}
60
62{
63 m_on_value = std::move(callback);
64}
65
67{
68 m_filter = std::move(filter);
69}
70
72{
73 return { .frames = m_frames.load(), .dropped = m_dropped.load(), .unparsed = m_unparsed.load() };
74}
75
76void SerialReader::push(std::span<const uint8_t> chunk)
77{
78 if (m_spec.parse == SerialParse::MIDI) {
79 parse_midi(chunk);
80 return;
81 }
82
83 const auto on_frame = [this](P::Message frame) { handle_frame(frame); };
84 std::visit(
85 [&](auto& framer) {
86 const auto report = framer.push(chunk, on_frame);
87 m_dropped.fetch_add(report.discarded);
88 if constexpr (std::is_same_v<std::decay_t<decltype(framer)>, P::IdleGapFramer>) {
89 arm_gap();
90 }
91 },
92 m_framer);
93}
94
96{
97 cancel_gap();
98 std::visit([](auto& framer) { framer.reset(); }, m_framer);
99 m_midi = {};
100}
101
102void SerialReader::handle_frame(P::Message frame)
103{
104 m_frames.fetch_add(1);
105
106 if (m_filter && m_filter(frame)) {
107 return;
108 }
109
110 switch (m_spec.parse) {
112 deliver(InputValue::make_bytes(std::vector<uint8_t>(frame.begin(), frame.end()), m_id, InputType::SERIAL));
113 break;
115 deliver(parse_numbers_of(frame, m_id));
116 break;
118 deliver(m_spec.parser ? m_spec.parser(frame) : std::nullopt);
119 break;
121 break;
122 }
123}
124
125void SerialReader::deliver(std::optional<InputValue> value)
126{
127 if (!value) {
128 m_unparsed.fetch_add(1);
129 return;
130 }
131
132 value->device_id = m_id;
133 value->source_type = InputType::SERIAL;
134 if (m_on_value) {
135 m_on_value(*value);
136 }
137}
138
139void SerialReader::parse_midi(std::span<const uint8_t> chunk)
140{
141 const auto emit = [this](uint8_t status, uint8_t first, uint8_t second) {
142 m_frames.fetch_add(1);
143 deliver(InputValue::make_midi(status, first, second, m_id));
144 };
145
146 for (const uint8_t byte : chunk) {
147 if (byte >= 0xF8) {
148 emit(byte, 0, 0);
149 continue;
150 }
151
152 if ((byte & 0x80) != 0) {
153 m_midi.have = 0;
154 if (byte >= 0xF0) {
155 m_midi.status = 0;
156 m_midi.need = 0;
157 m_midi.in_sysex = byte == 0xF0;
158 continue;
159 }
160 m_midi.in_sysex = false;
161 m_midi.status = byte;
162 const uint8_t kind = byte & 0xF0;
163 m_midi.need = (kind == 0xC0 || kind == 0xD0) ? 1 : 2;
164 continue;
165 }
166
167 if (m_midi.in_sysex || m_midi.status == 0) {
168 continue;
169 }
170
171 m_midi.data[m_midi.have++] = byte;
172 if (m_midi.have == m_midi.need) {
173 emit(m_midi.status, m_midi.data[0], m_midi.need == 2 ? m_midi.data[1] : uint8_t { 0 });
174 m_midi.have = 0;
175 }
176 }
177}
178
180{
181 cancel_gap();
182 const auto delay = std::max(m_spec.gap, std::chrono::milliseconds(1));
183 m_gap_timer.store(m_link.post_after(delay, [this] { handle_gap(); }));
184}
185
187{
188 if (const auto token = m_gap_timer.exchange(0); token != 0) {
189 m_link.cancel_post(token);
190 }
191}
192
194{
195 m_gap_timer.store(0);
196 const auto on_frame = [this](P::Message frame) { handle_frame(frame); };
197 if (auto* framer = std::get_if<P::IdleGapFramer>(&m_framer)) {
198 const auto report = framer->flush(on_frame);
199 m_dropped.fetch_add(report.discarded);
200 }
201}
202
203} // namespace MayaFlux::Core
std::atomic< uint64_t > m_frames
SerialReaderStats stats() const
std::variant< Transitive::Protocol::RawChunkFramer, Transitive::Protocol::LineFramer, Transitive::Protocol::DelimiterFramer, Transitive::Protocol::CobsFramer, Transitive::Protocol::SlipFramer, Transitive::Protocol::IdleGapFramer > Framer
void handle_frame(Transitive::Protocol::Message frame)
std::atomic< uint64_t > m_dropped
std::function< bool(Transitive::Protocol::Message message)> FrameFilter
std::atomic< ISerialLink::TimerToken > m_gap_timer
std::function< void(const InputValue &)> ValueCallback
void reset()
Drop the partial message, the running MIDI status and a pending gap.
std::atomic< uint64_t > m_unparsed
const SerialSpec & spec() const
SerialReader(uint32_t id, SerialSpec spec, ISerialLink &link)
void push(std::span< const uint8_t > chunk)
void deliver(std::optional< InputValue > value)
void set_frame_filter(FrameFilter filter)
static Framer make_framer(const SerialSpec &spec)
void parse_midi(std::span< const uint8_t > chunk)
void set_value_callback(ValueCallback callback)
@ SERIAL
Serial port communication (Arduino, etc.).
static InputValue make_bytes(std::vector< uint8_t > v, uint32_t dev_id, InputType src)
static InputValue make_midi(uint8_t status, uint8_t d1, uint8_t d2, uint32_t dev_id)
What a reader has seen since it was made.
What a serial device is: its line setup, framing and parsing, as a plain value.