use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not};
use std::rc::Rc;
use rustduck_sys::bridge::ffi;
use crate::buffer::encode_utf16;
use crate::error::native_exception;
use crate::{Error, Report, Result};
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Standards(pub u32);
impl Standards {
pub const NONE: Self = Self(0x00);
pub const MPEG: Self = Self(0x01);
pub const DVB: Self = Self(0x02);
pub const SCTE: Self = Self(0x04);
pub const ATSC: Self = Self(0x08);
pub const ISDB: Self = Self(0x10);
pub const JAPAN: Self = Self(0x20);
pub const ABNT: Self = Self(0x40);
pub const ALL: Self = Self(0x7f);
pub const fn bits(self) -> u32 {
self.0
}
pub const fn all() -> Self {
Self::ALL
}
}
impl BitOr for Standards {
type Output = Self;
fn bitor(self, rhs: Self) -> Self::Output {
Self(self.0 | rhs.0)
}
}
impl BitOrAssign for Standards {
fn bitor_assign(&mut self, rhs: Self) {
self.0 |= rhs.0;
}
}
impl BitAnd for Standards {
type Output = Self;
fn bitand(self, rhs: Self) -> Self::Output {
Self(self.0 & rhs.0)
}
}
impl BitAndAssign for Standards {
fn bitand_assign(&mut self, rhs: Self) {
self.0 &= rhs.0;
}
}
impl Not for Standards {
type Output = Self;
fn not(self) -> Self::Output {
Self(!self.0 & Self::ALL.0)
}
}
pub struct DuckContext {
native: cxx::UniquePtr<ffi::RustDuckDuckContext>,
report: Rc<Report>,
}
impl DuckContext {
pub fn new(report: Rc<Report>) -> Result<Rc<Self>> {
let native = ffi::rustduck_context_new(report.native())
.map_err(|error| native_exception("DuckContext::new", error))?;
if native.is_null() {
return Err(Error::NativeFailure {
operation: "DuckContext::new",
});
}
Ok(Rc::new(Self { native, report }))
}
pub fn report(&self) -> &Rc<Report> {
&self.report
}
pub fn set_default_charset(&mut self, charset: &str) -> Result<()> {
let charset = encode_utf16(charset);
let accepted =
ffi::rustduck_context_set_default_charset(self.native.pin_mut(), &charset)
.map_err(|error| native_exception("DuckContext::set_default_charset", error))?;
accepted.then_some(()).ok_or(Error::NativeFailure {
operation: "DuckContext::set_default_charset",
})
}
pub fn set_default_cas_id(&mut self, cas_id: u16) -> Result<()> {
ffi::rustduck_context_set_default_cas_id(self.native.pin_mut(), cas_id)
.map_err(|error| native_exception("DuckContext::set_default_cas_id", error))
}
pub fn set_default_pds(&mut self, pds: u32) -> Result<()> {
ffi::rustduck_context_set_default_pds(self.native.pin_mut(), pds)
.map_err(|error| native_exception("DuckContext::set_default_pds", error))
}
pub fn add_standards(&mut self, standards: Standards) -> Result<()> {
ffi::rustduck_context_add_standards(self.native.pin_mut(), standards.bits())
.map_err(|error| native_exception("DuckContext::add_standards", error))
}
pub fn standards(&self) -> Result<Standards> {
ffi::rustduck_context_standards(
self.native
.as_ref()
.expect("DuckContext construction rejects null owners"),
)
.map(Standards)
.map_err(|error| native_exception("DuckContext::standards", error))
}
pub fn reset_standards(&mut self, standards: Standards) -> Result<()> {
ffi::rustduck_context_reset_standards(self.native.pin_mut(), standards.bits())
.map_err(|error| native_exception("DuckContext::reset_standards", error))
}
pub fn set_time_reference_offset(&mut self, offset_millis: i64) -> Result<()> {
ffi::rustduck_context_set_time_reference_offset(self.native.pin_mut(), offset_millis)
.map_err(|error| native_exception("DuckContext::set_time_reference_offset", error))
}
pub fn set_time_reference(&mut self, name: &str) -> Result<()> {
let name = encode_utf16(name);
let accepted = ffi::rustduck_context_set_time_reference(self.native.pin_mut(), &name)
.map_err(|error| native_exception("DuckContext::set_time_reference", error))?;
accepted.then_some(()).ok_or(Error::NativeFailure {
operation: "DuckContext::set_time_reference",
})
}
pub(crate) fn native(&self) -> &ffi::RustDuckDuckContext {
self.native
.as_ref()
.expect("DuckContext construction rejects null owners")
}
}
#[cfg(test)]
mod tests {
use super::Standards;
#[test]
fn all_covers_every_defined_standard() {
let defined = Standards::MPEG
| Standards::DVB
| Standards::SCTE
| Standards::ATSC
| Standards::ISDB
| Standards::JAPAN
| Standards::ABNT;
assert_eq!(Standards::ALL.bits(), 0x7f);
assert_eq!(Standards::all().bits(), 0x7f);
assert_eq!(defined.bits(), Standards::ALL.bits());
}
#[test]
fn not_keeps_only_defined_standard_bits() {
assert_eq!((!Standards::NONE).bits(), Standards::ALL.bits());
assert_eq!((!Standards::ALL).bits(), Standards::NONE.bits());
assert_eq!((!Standards::MPEG).bits(), 0x7e);
assert_eq!((!Standards(0xffff_ffff)).bits(), Standards::NONE.bits());
assert_eq!((!Standards(0x80)).bits(), Standards::ALL.bits());
}
}