535 lines
19 KiB
C++
535 lines
19 KiB
C++
#include "tacdec.hh"
|
|
#include "components/ffmsep/cpdecoder.hh"
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <new>
|
|
#include <optional>
|
|
#include <qlogging.h>
|
|
#include <vector>
|
|
#include <qdebug.h>
|
|
#include <iostream>
|
|
|
|
namespace ffmsep::tactile {
|
|
namespace {
|
|
|
|
constexpr std::size_t kHeaderSize = 4U; // start bytes + length field
|
|
constexpr std::size_t kFixedSectionSize = 1U + 1U + 1U + 4U + 2U + 1U; // address..status
|
|
constexpr std::size_t kMinimumFrameSize = kHeaderSize + kFixedSectionSize + 1U; // + CRC byte
|
|
constexpr std::uint8_t kCrcPolynomial = 0x07U;
|
|
constexpr std::uint8_t kCrcInitial = 0x00U;
|
|
constexpr std::uint8_t kCrcXorOut = 0xA9U;
|
|
constexpr std::array<std::uint8_t, 2> kStartSequence{
|
|
kStartByteFirst,
|
|
kStartByteSecond
|
|
};
|
|
constexpr std::size_t kAbsoluteMaxPayloadBytes = 4096U; // 硬上限，防止异常配置撑爆内存
|
|
constexpr std::array<std::uint8_t, 2> kPiezoresistiveBStartSequence{
|
|
kPiezoresistiveBStartByteFirst,
|
|
kPiezoresistiveBStartByteSecond
|
|
};
|
|
constexpr std::array<std::uint8_t, 2> kPiezoresistiveBEndSequence{
|
|
kPiezoresistiveBEndByteFirst,
|
|
kPiezoresistiveBEndByteSecond
|
|
};
|
|
constexpr std::size_t kPiezoresistiveBPayloadSize =
|
|
kPiezoresistiveBValueCount * 2U;
|
|
constexpr std::size_t kPiezoresistiveBFrameSize =
|
|
kPiezoresistiveBStartSequence.size() + kPiezoresistiveBPayloadSize + kPiezoresistiveBEndSequence.size();
|
|
|
|
struct TactileDecoderContext {
|
|
std::vector<std::uint8_t> fifo;
|
|
bool end_of_stream = false;
|
|
std::int64_t next_pts = 0;
|
|
CPCodecID codec_id = CPCodecID::Unknow;
|
|
std::size_t max_payload_bytes = kPiezoresistiveBPayloadSize;
|
|
std::size_t max_frame_bytes = kHeaderSize + kFixedSectionSize + kPiezoresistiveBPayloadSize + 1U;
|
|
std::size_t max_fifo_bytes = (kHeaderSize + kFixedSectionSize + kPiezoresistiveBPayloadSize + 1U) * 2U;
|
|
|
|
void update_limits(std::size_t payload_bytes) {
|
|
const auto clamped_payload = std::min<std::size_t>(
|
|
std::max<std::size_t>(payload_bytes, 2U),
|
|
kAbsoluteMaxPayloadBytes);
|
|
max_payload_bytes = clamped_payload;
|
|
max_frame_bytes = kHeaderSize + kFixedSectionSize + max_payload_bytes + 1U;
|
|
max_fifo_bytes = max_frame_bytes * 2U;
|
|
}
|
|
};
|
|
|
|
const std::uint8_t* buffer_data(const std::vector<std::uint8_t>& buf) {
|
|
return buf.empty() ? nullptr : buf.data();
|
|
}
|
|
|
|
std::uint8_t crc8_with_xorout(const std::uint8_t* data, std::size_t length) {
|
|
#if 0
|
|
std::uint8_t reg = kCrcInitial;
|
|
for (std::size_t i = 0; i < length; ++i) {
|
|
reg ^= data[i];
|
|
for (int bit = 0; bit < 8; ++bit) {
|
|
if ((reg & 0x80U) != 0U) {
|
|
reg = static_cast<std::uint8_t>((reg << 1U) ^ kCrcPolynomial);
|
|
}
|
|
else {
|
|
reg = static_cast<std::uint8_t>(reg << 1U);
|
|
}
|
|
}
|
|
}
|
|
return static_cast<std::uint8_t>(reg ^ kCrcXorOut);
|
|
#endif
|
|
constexpr std::uint8_t kPolynomial = 0x07;
|
|
constexpr std::uint8_t kInitial = 0x00;
|
|
constexpr std::uint8_t kXorOut =
|
|
0x55; // CRC-8/ITU params match device expectation
|
|
|
|
std::uint8_t reg = kInitial;
|
|
for (std::size_t idx = 0; idx < length; ++idx) {
|
|
reg = static_cast<std::uint8_t>(reg ^ data[idx]);
|
|
for (int bit = 0; bit < 8; ++bit) {
|
|
if ((reg & 0x80U) != 0U) {
|
|
reg = static_cast<std::uint8_t>((reg << 1U) ^ kPolynomial);
|
|
}
|
|
else {
|
|
reg = static_cast<std::uint8_t>(reg << 1U);
|
|
}
|
|
}
|
|
}
|
|
return static_cast<std::uint8_t>(reg ^ kXorOut);
|
|
}
|
|
|
|
TactileDecoderContext* get_priv(CPCodecContext* ctx) {
|
|
return ctx ? ctx->priv_as<TactileDecoderContext>() : nullptr;
|
|
}
|
|
|
|
template<std::size_t N>
|
|
void keep_partial_start_prefix(std::vector<std::uint8_t>& buf, const std::array<std::uint8_t, N>& start_sequence) {
|
|
if (buf.empty() || N == 0U) {
|
|
return;
|
|
}
|
|
const std::size_t max_prefix = std::min<std::size_t>(N - 1U, buf.size());
|
|
for (std::size_t len = max_prefix; len > 0; --len) {
|
|
const auto seq_begin = start_sequence.begin();
|
|
const auto seq_end = seq_begin + static_cast<std::ptrdiff_t>(len);
|
|
const auto buf_begin =
|
|
buf.end() - static_cast<std::ptrdiff_t>(len);
|
|
if (std::equal(seq_begin, seq_end, buf_begin)) {
|
|
std::vector<std::uint8_t> tail(buf_begin, buf.end());
|
|
buf.swap(tail);
|
|
return;
|
|
}
|
|
}
|
|
buf.clear();
|
|
}
|
|
|
|
void trim_fifo_if_needed(std::vector<std::uint8_t>& buf, std::size_t max_fifo_bytes) {
|
|
if (buf.size() <= max_fifo_bytes) {
|
|
return;
|
|
}
|
|
const auto excess = buf.size() - max_fifo_bytes;
|
|
buf.erase(buf.begin(), buf.begin() + static_cast<std::ptrdiff_t>(excess));
|
|
}
|
|
|
|
std::atomic<std::size_t>& expected_payload_bytes_for_tactile() {
|
|
static std::atomic<std::size_t> expected{kPiezoresistiveBPayloadSize};
|
|
return expected;
|
|
}
|
|
|
|
int tactile_init(CPCodecContext* ctx) {
|
|
if (!ctx) {
|
|
return CP_ERROR_INVALID_ARGUMENT;
|
|
}
|
|
if (!ctx->priv_data) {
|
|
ctx->ensure_priv_storage(sizeof(TactileDecoderContext));
|
|
}
|
|
auto* storage = static_cast<TactileDecoderContext*>(ctx->priv_data);
|
|
new (storage) TactileDecoderContext();
|
|
storage->codec_id = ctx->codec ? ctx->codec->id : CPCodecID::Unknow;
|
|
if (storage->codec_id == CPCodecID::Tactile) {
|
|
const auto expected = expected_payload_bytes_for_tactile().load(std::memory_order_relaxed);
|
|
storage->update_limits(expected);
|
|
}
|
|
else {
|
|
storage->update_limits(kPiezoresistiveBPayloadSize);
|
|
}
|
|
return CP_SUCCESS;
|
|
}
|
|
|
|
void tactile_close(CPCodecContext* ctx) {
|
|
if (!ctx || !ctx->priv_data) {
|
|
return;
|
|
}
|
|
if (auto* priv = get_priv(ctx); priv != nullptr) {
|
|
priv->~TactileDecoderContext();
|
|
}
|
|
}
|
|
|
|
int tactile_send_packet(CPCodecContext* ctx, const CPPacket& packet) {
|
|
auto priv = get_priv(ctx);
|
|
if (!priv) {
|
|
return CP_ERROR_INVALID_STATE;
|
|
}
|
|
if (packet.flush) {
|
|
priv->fifo.clear();
|
|
priv->end_of_stream = false;
|
|
priv->next_pts = 0;
|
|
}
|
|
|
|
if (!packet.payload.empty()) {
|
|
priv->fifo.insert(priv->fifo.end(), packet.payload.begin(), packet.payload.end());
|
|
trim_fifo_if_needed(priv->fifo, priv->max_fifo_bytes);
|
|
}
|
|
|
|
if (packet.end_of_stream) {
|
|
priv->end_of_stream = true;
|
|
}
|
|
|
|
return CP_SUCCESS;
|
|
}
|
|
|
|
int tactile_receive_frame(CPCodecContext* ctx, CPFrame& frame) {
|
|
auto* priv = get_priv(ctx);
|
|
if (!priv) {
|
|
return CP_ERROR_INVALID_STATE;
|
|
}
|
|
|
|
auto& buf = priv->fifo;
|
|
|
|
while (true) {
|
|
if (buf.empty()) {
|
|
if (priv->end_of_stream) {
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
const auto start_it = std::search(buf.begin(), buf.end(), kStartSequence.begin(), kStartSequence.end());
|
|
if (start_it == buf.end()) {
|
|
keep_partial_start_prefix(buf, kStartSequence);
|
|
if (priv->end_of_stream) {
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
if (start_it != buf.begin()) {
|
|
buf.erase(buf.begin(), start_it);
|
|
}
|
|
|
|
if (buf.size() < kHeaderSize) {
|
|
if (priv->end_of_stream) {
|
|
buf.clear();
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
const std::uint8_t* data = buffer_data(buf);
|
|
if (!data) {
|
|
buf.clear();
|
|
continue;
|
|
}
|
|
|
|
const std::uint16_t data_length =
|
|
static_cast<std::uint16_t>(data[2]) | static_cast<std::uint16_t>(static_cast<std::uint16_t>(data[3]) << 8U);
|
|
|
|
if (data_length < kFixedSectionSize) {
|
|
buf.erase(buf.begin());
|
|
continue;
|
|
}
|
|
|
|
const std::size_t total_frame_length = kHeaderSize + static_cast<std::size_t>(data_length) + 1U;
|
|
if (total_frame_length > priv->max_frame_bytes) {
|
|
buf.erase(buf.begin());
|
|
continue;
|
|
}
|
|
if (buf.size() < total_frame_length) {
|
|
if (priv->end_of_stream) {
|
|
buf.clear();
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
const auto crc_offset = total_frame_length - 1U;
|
|
const std::uint8_t computed_crc =
|
|
crc8_with_xorout(data, crc_offset); // header..last payload byte (excludes CRC)
|
|
const std::uint8_t frame_crc = data[crc_offset];
|
|
if (computed_crc != frame_crc) {
|
|
buf.erase(buf.begin());
|
|
continue;
|
|
}
|
|
|
|
frame.data.assign(buf.begin(), buf.begin() + static_cast<std::ptrdiff_t>(total_frame_length));
|
|
frame.pts = priv->next_pts++;
|
|
frame.key_frame = true;
|
|
frame.valid = true;
|
|
|
|
buf.erase(buf.begin(), buf.begin() + static_cast<std::ptrdiff_t>(total_frame_length));
|
|
return CP_SUCCESS;
|
|
}
|
|
}
|
|
|
|
int tactile_b_receive_frame(CPCodecContext* ctx, CPFrame& frame) {
|
|
auto* priv = get_priv(ctx);
|
|
if (!priv) {
|
|
return CP_ERROR_INVALID_STATE;
|
|
}
|
|
|
|
auto& buf = priv->fifo;
|
|
while (true) {
|
|
if (buf.size() < kPiezoresistiveBStartSequence.size()) {
|
|
if (priv->end_of_stream) {
|
|
buf.clear();
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
const auto start_it = std::search(buf.begin(),
|
|
buf.end(),
|
|
kPiezoresistiveBStartSequence.begin(),
|
|
kPiezoresistiveBStartSequence.end());
|
|
if (start_it == buf.end()) {
|
|
keep_partial_start_prefix(buf, kPiezoresistiveBStartSequence);
|
|
if (priv->end_of_stream) {
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
if (start_it != buf.begin()) {
|
|
buf.erase(buf.begin(), start_it);
|
|
}
|
|
|
|
if (buf.size() < kPiezoresistiveBFrameSize) {
|
|
if (priv->end_of_stream) {
|
|
buf.clear();
|
|
priv->end_of_stream = false;
|
|
return CP_ERROR_EOF;
|
|
}
|
|
return CP_ERROR_EAGAIN;
|
|
}
|
|
|
|
const auto end_offset = kPiezoresistiveBFrameSize - kPiezoresistiveBEndSequence.size();
|
|
const auto end_it = buf.begin() + static_cast<std::ptrdiff_t>(end_offset);
|
|
if (!std::equal(end_it,
|
|
end_it + static_cast<std::ptrdiff_t>(kPiezoresistiveBEndSequence.size()),
|
|
kPiezoresistiveBEndSequence.begin())) {
|
|
buf.erase(buf.begin());
|
|
continue;
|
|
}
|
|
|
|
frame.data.assign(buf.begin(),
|
|
buf.begin() + static_cast<std::ptrdiff_t>(kPiezoresistiveBFrameSize));
|
|
frame.pts = priv->next_pts++;
|
|
frame.key_frame = true;
|
|
frame.valid = true;
|
|
|
|
buf.erase(buf.begin(),
|
|
buf.begin() + static_cast<std::ptrdiff_t>(kPiezoresistiveBFrameSize));
|
|
return CP_SUCCESS;
|
|
}
|
|
}
|
|
|
|
const CPCodec kTactileCodec{
|
|
.name = "tactile_serial",
|
|
.long_name = "Framed tactile sensor serial protocol decoder",
|
|
.type = CPMediaType::Data,
|
|
.id = CPCodecID::Tactile,
|
|
.priv_data_size = sizeof(TactileDecoderContext),
|
|
.init = &tactile_init,
|
|
.close = &tactile_close,
|
|
.send_packet = &tactile_send_packet,
|
|
.receive_frame = &tactile_receive_frame
|
|
};
|
|
|
|
const CPCodec kTactileBCodec{
|
|
.name = "tactile_serial_b",
|
|
.long_name = "Piezoresistive B tactile serial protocol decoder",
|
|
.type = CPMediaType::Data,
|
|
.id = CPCodecID::PiezoresistiveB,
|
|
.priv_data_size = sizeof(TactileDecoderContext),
|
|
.init = &tactile_init,
|
|
.close = &tactile_close,
|
|
.send_packet = &tactile_send_packet,
|
|
.receive_frame = &tactile_b_receive_frame
|
|
};
|
|
} // namespace
|
|
|
|
std::optional<TactileFrame> parse_frame(const CPFrame& frame) {
|
|
// if (!frame.valid || frame.data.size() < kMinimumFrameSize) {
|
|
// return std::nullopt;
|
|
// }
|
|
std::cout << "frame valid:" << frame.valid << ", frame.data.size:" << frame.data.size() << std::endl;
|
|
|
|
const auto* bytes = frame.data.data();
|
|
const std::size_t size = frame.data.size();
|
|
|
|
if (bytes[0] != kStartByteFirst || bytes[1] != kStartByteSecond) {
|
|
return std::nullopt;
|
|
}
|
|
std::cout << "frame valid1:" << frame.valid << ", frame.data.size1:" << frame.data.size() << std::endl;
|
|
const std::uint16_t data_length =
|
|
static_cast<std::uint16_t>(bytes[2]) | static_cast<std::uint16_t>(static_cast<std::uint16_t>(bytes[3]) << 8U);
|
|
qDebug() << "data_length: " << data_length;
|
|
if (data_length < kFixedSectionSize) {
|
|
return std::nullopt;
|
|
}
|
|
std::cout << "frame valid2:" << frame.valid << ", frame.data.size1:" << frame.data.size() << std::endl;
|
|
const std::size_t expected_size = kHeaderSize + static_cast<std::size_t>(data_length) + 1U;
|
|
if (size != expected_size) {
|
|
return std::nullopt;
|
|
}
|
|
std::cout << "frame valid3:" << frame.valid << ", frame.data.size1:" << frame.data.size() << std::endl;
|
|
const std::uint8_t crc_byte = bytes[expected_size - 1U];
|
|
const std::uint8_t computed_crc =
|
|
crc8_with_xorout(bytes, expected_size - 1U); // header..last payload byte
|
|
if (computed_crc != crc_byte) {
|
|
return std::nullopt;
|
|
}
|
|
std::cout << "frame valid4:" << frame.valid << ", frame.data.size1:" << frame.data.size() << std::endl;
|
|
const std::uint8_t device_address = bytes[4];
|
|
const std::uint8_t reserved = bytes[5];
|
|
const std::uint8_t response_function = bytes[6];
|
|
const std::uint32_t start_address =
|
|
static_cast<std::uint32_t>(bytes[7]) | (static_cast<std::uint32_t>(bytes[8]) << 8U) | (static_cast<std::uint32_t>(bytes[9]) << 16U) | (static_cast<std::uint32_t>(bytes[10]) << 24U);
|
|
const std::uint16_t return_byte_count =
|
|
static_cast<std::uint16_t>(bytes[11]) | (static_cast<std::uint16_t>(bytes[12]) << 8U);
|
|
const std::uint8_t status = bytes[13];
|
|
|
|
const std::size_t payload_offset = kHeaderSize + kFixedSectionSize;
|
|
const std::size_t payload_available =
|
|
data_length > kFixedSectionSize ? static_cast<std::size_t>(data_length) - kFixedSectionSize : 0U;
|
|
const std::size_t requested_payload = static_cast<std::size_t>(return_byte_count);
|
|
if (payload_available < requested_payload) {
|
|
return std::nullopt;
|
|
}
|
|
std::cout << "frame valid5:" << frame.valid << ", frame.data.size1:" << frame.data.size() << std::endl;
|
|
TactileFrame parsed{};
|
|
parsed.device_address = device_address;
|
|
parsed.reserved = reserved;
|
|
parsed.response_function = response_function;
|
|
parsed.function = static_cast<FunctionCode>(response_function & 0x7FU);
|
|
parsed.start_address = start_address;
|
|
parsed.return_byte_count = return_byte_count;
|
|
parsed.status = status;
|
|
parsed.payload.assign(bytes + payload_offset, bytes + payload_offset + requested_payload);
|
|
return parsed;
|
|
}
|
|
|
|
std::vector<std::uint16_t> parse_pressure_values(const TactileFrame& frame) {
|
|
std::cout << "parse_pressure_values" << std::endl;
|
|
const auto requested_bytes = static_cast<std::size_t>(frame.return_byte_count);
|
|
const auto usable_bytes = std::min(requested_bytes, frame.payload.size());
|
|
if (usable_bytes == 0U || (usable_bytes % 2U != 0U)) {
|
|
return {};
|
|
}
|
|
std::vector<std::uint16_t> values;
|
|
values.reserve(usable_bytes / 2U);
|
|
for (std::size_t idx = 0; idx + 1U < usable_bytes; idx += 2U) {
|
|
const std::uint16_t value = static_cast<std::uint16_t>(
|
|
static_cast<std::uint16_t>(frame.payload[idx]) | static_cast<std::uint16_t>(frame.payload[idx + 1U] << 8U));
|
|
values.push_back(value);
|
|
}
|
|
return values;
|
|
}
|
|
|
|
std::optional<MatrixSize> parse_matrix_size_payload(const TactileFrame& frame) {
|
|
if (frame.payload.size() != 2U) {
|
|
return std::nullopt;
|
|
}
|
|
MatrixSize size{};
|
|
size.long_edge = frame.payload[0];
|
|
size.short_edge = frame.payload[1];
|
|
return size;
|
|
}
|
|
|
|
std::vector<std::uint16_t> parse_piezoresistive_b_pressures(const CPFrame& frame) {
|
|
// if (!frame.valid) {
|
|
// return {};
|
|
// }
|
|
// if (frame.data.size() != kPiezoresistiveBFrameSize) {
|
|
// return {};
|
|
// }
|
|
// if (frame.data.size() < kPiezoresistiveBFrameSize) {
|
|
// return {};
|
|
// }
|
|
// if (frame.data[0] != kPiezoresistiveBStartByteFirst || frame.data[1] != kPiezoresistiveBStartByteSecond) {
|
|
// return {};
|
|
// }
|
|
const auto end_offset = kPiezoresistiveBFrameSize - kPiezoresistiveBEndSequence.size();
|
|
// if (frame.data[end_offset] != kPiezoresistiveBEndByteFirst || frame.data[end_offset + 1U] != kPiezoresistiveBEndByteSecond) {
|
|
// return {};
|
|
// }
|
|
|
|
std::vector<std::uint16_t> values;
|
|
values.reserve(kPiezoresistiveBValueCount);
|
|
std::cout << "valuessize:" << values.size() << std::endl;
|
|
const auto payload_offset = kPiezoresistiveBStartSequence.size();
|
|
for (std::size_t idx = 0; idx < kPiezoresistiveBValueCount; ++idx) {
|
|
const auto base = payload_offset + idx * 2U;
|
|
if (base + 1U >= frame.data.size()) {
|
|
break;
|
|
}
|
|
const auto hi = static_cast<std::uint16_t>(frame.data[base]);
|
|
const auto lo = static_cast<std::uint16_t>(frame.data[base + 1U]);
|
|
values.push_back(static_cast<std::uint16_t>((hi << 8U) | lo));
|
|
}
|
|
return values;
|
|
}
|
|
|
|
std::vector<std::uint8_t> extract_piezoresistive_b_payload(const CPFrame& frame) {
|
|
if (!frame.valid) {
|
|
return {};
|
|
}
|
|
if (frame.data.size() != kPiezoresistiveBFrameSize) {
|
|
return {};
|
|
}
|
|
if (frame.data[0] != kPiezoresistiveBStartByteFirst || frame.data[1] != kPiezoresistiveBStartByteSecond) {
|
|
return {};
|
|
}
|
|
const auto payload_offset = kPiezoresistiveBStartSequence.size();
|
|
const auto payload_end = payload_offset + kPiezoresistiveBPayloadSize;
|
|
if (frame.data.size() < payload_end + kPiezoresistiveBEndSequence.size()) {
|
|
return {};
|
|
}
|
|
if (frame.data[payload_end] != kPiezoresistiveBEndByteFirst || frame.data[payload_end + 1U] != kPiezoresistiveBEndByteSecond) {
|
|
return {};
|
|
}
|
|
|
|
return std::vector<std::uint8_t>(
|
|
frame.data.begin() + static_cast<std::ptrdiff_t>(payload_offset),
|
|
frame.data.begin() + static_cast<std::ptrdiff_t>(payload_end));
|
|
}
|
|
|
|
void set_tactile_expected_payload_bytes(std::size_t bytes) {
|
|
const auto clamped = std::min<std::size_t>(
|
|
std::max<std::size_t>(bytes, 2U),
|
|
kAbsoluteMaxPayloadBytes);
|
|
expected_payload_bytes_for_tactile().store(clamped, std::memory_order_relaxed);
|
|
}
|
|
|
|
const CPCodec* tactile_codec() {
|
|
return &kTactileCodec;
|
|
}
|
|
|
|
void register_tactile_codec() {
|
|
cpcodec_register(&kTactileCodec);
|
|
}
|
|
|
|
const CPCodec* tactile_b_codec() {
|
|
return &kTactileBCodec;
|
|
}
|
|
|
|
void register_tactile_b_codec() {
|
|
cpcodec_register(&kTactileBCodec);
|
|
}
|
|
} // namespace ffmsep::tactile
|