#include "rustduck-sys/native/bridge/processor.h"
#include "rustduck-sys/native/bridge/test_hooks.h"
#include "rustduck-sys/native/tspy.h"
#include "rustduck-sys/src/bridge.rs.h"
#include <condition_variable>
#include <limits>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <utility>
#include <tsTSProcessor.h>
namespace {
long checked_long(std::int64_t value) {
if (value < std::numeric_limits<long>::min() ||
value > std::numeric_limits<long>::max()) {
throw std::invalid_argument(
"processor numeric option is outside native long range");
}
return static_cast<long>(value);
}
const std::uint8_t *buffer_data(const rust::Vec<std::uint8_t> &buffer) {
return buffer.empty() ? nullptr : buffer.data();
}
}
class RustDuckProcessorAbortToken final {
public:
explicit RustDuckProcessorAbortToken(void *processor) noexcept
: processor_(processor) {}
void request() const noexcept {
void *processor = nullptr;
{
std::unique_lock lock(mutex_);
if (closed_) {
return;
}
++requests_in_flight_;
processor = processor_;
}
tspyAbortTSProcessor(processor);
{
std::unique_lock lock(mutex_);
--requests_in_flight_;
if (requests_in_flight_ == 0) {
changed_.notify_all();
}
}
}
void close() noexcept {
std::unique_lock lock(mutex_);
closed_ = true;
processor_ = nullptr;
changed_.wait(lock, [this] { return requests_in_flight_ == 0; });
}
private:
mutable std::mutex mutex_;
mutable std::condition_variable changed_;
void *processor_;
mutable size_t requests_in_flight_ = 0;
bool closed_ = false;
};
RustDuckTSProcessor::RustDuckTSProcessor(std::shared_ptr<void> processor)
: processor_(std::move(processor)),
abort_token_(
std::make_shared<RustDuckProcessorAbortToken>(processor_.get())) {}
RustDuckTSProcessor::~RustDuckTSProcessor() noexcept { abort_token_->close(); }
void *RustDuckTSProcessor::raw() const noexcept { return processor_.get(); }
void RustDuckTSProcessor::retain_handler(const RustDuckMemoryHandler &handler) {
handlers_.push_back(handler.retain());
}
const std::shared_ptr<RustDuckProcessorAbortToken> &
RustDuckTSProcessor::abort_token() const noexcept {
return abort_token_;
}
std::unique_ptr<RustDuckTSProcessor>
rustduck_processor_new(const RustDuckReport &report) {
rustduck_test_maybe_fail(RustDuckFailurePoint::ProcessorConstruct);
auto processor =
std::shared_ptr<void>(tspyNewTSProcessor(report.raw()),
[report = report.retain()](void *pointer) {
if (pointer != nullptr) {
tspyDeleteTSProcessor(pointer);
}
});
if (!processor) {
throw std::runtime_error("native processor construction failed");
}
return std::make_unique<RustDuckTSProcessor>(std::move(processor));
}
void rustduck_processor_register_input(RustDuckTSProcessor &processor,
const RustDuckMemoryHandler &handler) {
rustduck_test_maybe_fail(RustDuckFailurePoint::ProcessorRegisterHandler);
processor.retain_handler(handler);
tspyPluginEventHandlerRegisterInput(processor.raw(), handler.raw());
}
void rustduck_processor_register_output(RustDuckTSProcessor &processor,
const RustDuckMemoryHandler &handler) {
rustduck_test_maybe_fail(RustDuckFailurePoint::ProcessorRegisterHandler);
processor.retain_handler(handler);
tspyPluginEventHandlerRegisterOutput(processor.raw(), handler.raw());
}
bool rustduck_processor_start(RustDuckTSProcessor &processor,
const RustDuckProcessorConfig &config) {
rustduck_test_maybe_fail(RustDuckFailurePoint::ProcessorStart);
if (config.plugins.size() % sizeof(std::uint16_t) != 0) {
throw std::invalid_argument(
"processor plugin buffer is not UTF-16 aligned");
}
const tspyTSProcessorArgs args{
checked_long(config.ignore_joint_termination),
checked_long(config.buffer_size),
checked_long(config.max_flushed_packets),
checked_long(config.max_input_packets),
checked_long(config.max_output_packets),
checked_long(config.initial_input_packets),
checked_long(config.add_input_stuffing_0),
checked_long(config.add_input_stuffing_1),
checked_long(config.add_start_stuffing),
checked_long(config.add_stop_stuffing),
checked_long(config.bitrate),
checked_long(config.bitrate_adjust_interval),
checked_long(config.receive_timeout),
config.log_plugin_index ? 1L : 0L,
const_cast<std::uint8_t *>(buffer_data(config.plugins)),
config.plugins.size(),
};
return tspyStartTSProcessor(processor.raw(), &args);
}
void rustduck_processor_abort(RustDuckTSProcessor &processor) {
processor.abort_token()->request();
}
void rustduck_processor_wait(RustDuckTSProcessor &processor) {
tspyWaitTSProcessor(processor.raw());
}
bool rustduck_processor_is_started(const RustDuckTSProcessor &processor) {
return static_cast<ts::TSProcessor *>(processor.raw())->isStarted();
}
std::shared_ptr<RustDuckProcessorAbortToken>
rustduck_processor_abort_token(const RustDuckTSProcessor &processor) {
return processor.abort_token();
}
void rustduck_processor_abort_token_request(
const RustDuckProcessorAbortToken &token) {
token.request();
}