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/analyzer_pmt.h"

#include <tsBinaryTable.h>
#include <tsCADescriptor.h>
#include <tsPAT.h>
#include <tsPMT.h>
#include <tsTID.h>

RustDuckAnalyzerPmtCollector::RustDuckAnalyzerPmtCollector(ts::DuckContext &context)
    : context_(context), demux_(context, this) {
  demux_.addPID(ts::PID_PAT);
}

void RustDuckAnalyzerPmtCollector::feed_packet(const ts::TSPacket &packet) {
  demux_.feedPacket(packet);
}

void RustDuckAnalyzerPmtCollector::reset() {
  demux_.reset();
  pmt_pids_.clear();
  ca_descriptors_.clear();
  ts::PIDSet filter;
  filter.set(ts::PID_PAT);
  demux_.setPIDFilter(filter);
}

const RustDuckAnalyzerCaMap &RustDuckAnalyzerPmtCollector::ca_descriptors() const noexcept {
  return ca_descriptors_;
}

void RustDuckAnalyzerPmtCollector::handleTable(ts::SectionDemux &,
                                                const ts::BinaryTable &table) {
  if (table.tableId() == ts::TID_PAT && table.sourcePID() == ts::PID_PAT) {
    handle_pat(table);
  } else if (table.tableId() == ts::TID_PMT) {
    handle_pmt(table);
  }
}

void RustDuckAnalyzerPmtCollector::handle_pat(const ts::BinaryTable &table) {
  const ts::PAT pat(context_, table);
  std::map<std::uint16_t, ts::PID> next;
  for (const auto &[service_id, pmt_pid] : pat.pmts) {
    next.emplace(service_id, pmt_pid);
  }
  for (const auto &[service_id, pmt_pid] : pmt_pids_) {
    const auto replacement = next.find(service_id);
    if (replacement == next.end() || replacement->second != pmt_pid) {
      demux_.removePID(pmt_pid);
      ca_descriptors_.erase(service_id);
    }
  }
  for (const auto &[service_id, pmt_pid] : next) {
    const auto current = pmt_pids_.find(service_id);
    if (current == pmt_pids_.end() || current->second != pmt_pid) {
      demux_.addPID(pmt_pid);
    }
  }
  pmt_pids_ = std::move(next);
}

void RustDuckAnalyzerPmtCollector::handle_pmt(const ts::BinaryTable &table) {
  const auto service = pmt_pids_.find(table.tableIdExtension());
  if (service == pmt_pids_.end()) {
    return;
  }
  const ts::PMT pmt(context_, table);
  if (pmt.service_id != service->first) {
    return;
  }
  auto &descriptors = ca_descriptors_[pmt.service_id];
  descriptors.clear();
  for (const auto &descriptor : pmt.descs) {
    if (descriptor.tag() == ts::DID_MPEG_CA) {
      const ts::CADescriptor ca(context_, descriptor);
      descriptors.push_back({ca.cas_id, ca.ca_pid, true, false, 0});
    }
  }
  for (const auto &[elementary_pid, stream] : pmt.streams) {
    for (const auto &descriptor : stream.descs) {
      if (descriptor.tag() == ts::DID_MPEG_CA) {
        const ts::CADescriptor ca(context_, descriptor);
        descriptors.push_back({ca.cas_id, ca.ca_pid, false, true, elementary_pid});
      }
    }
  }
}