rustduck-sys 1.1.0

Raw Rust FFI bindings to the C ABI used by TSDuck's Python API
Documentation
#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();
}

} // namespace

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();
}