#![deny(missing_docs)]
#![doc = include_str!("../README.md")]
use rusttorch_core::{Device, Tensor};
use rusttorch_data::{MemoryFootprint, PinMemory};
use serde::{Deserialize, Serialize};
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum CodecError {
#[error(transparent)]
Io(#[from] std::io::Error),
#[error("{0}")]
Invalid(String),
#[error(transparent)]
Limit(#[from] rusttorch_core::RustTorchError),
#[error(transparent)]
Tensor(#[from] tch::TchError),
#[cfg(any(feature = "system", feature = "vcpkg"))]
#[error(transparent)]
Native(#[from] rsmpeg::error::RsmpegError),
}
pub type Result<T> = std::result::Result<T, CodecError>;
#[derive(Clone, Copy, Debug, Serialize, PartialEq, Eq)]
pub struct TimeBase {
numerator: u32,
denominator: u32,
}
impl TimeBase {
pub fn new(numerator: u32, denominator: u32) -> Result<Self> {
if numerator == 0 || denominator == 0 {
return Err(CodecError::Invalid(
"time base requires positive numerator and denominator".into(),
));
}
Ok(Self {
numerator,
denominator,
})
}
pub const fn numerator(self) -> u32 {
self.numerator
}
pub const fn denominator(self) -> u32 {
self.denominator
}
pub fn seconds(self, ticks: i64) -> f64 {
ticks as f64 * self.numerator as f64 / self.denominator as f64
}
pub fn rescale(self, ticks: i64, target: Self) -> Result<i64> {
let value = (ticks as i128) * (self.numerator as i128) * (target.denominator as i128)
/ ((self.denominator as i128) * (target.numerator as i128));
i64::try_from(value)
.map_err(|_| CodecError::Invalid("rescaled timestamp overflows i64".into()))
}
}
impl<'de> Deserialize<'de> for TimeBase {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
#[derive(Deserialize)]
struct Wire {
numerator: u32,
denominator: u32,
}
let w = Wire::deserialize(d)?;
Self::new(w.numerator, w.denominator).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct Timestamp {
pub ticks: i64,
pub time_base: TimeBase,
}
impl Timestamp {
pub fn seconds(self) -> f64 {
self.time_base.seconds(self.ticks)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StreamKind {
Video,
Audio,
}
#[derive(Debug)]
pub struct VideoFrame {
pub pixels: Tensor,
pub timestamp: Option<Timestamp>,
}
#[derive(Debug)]
pub struct AudioFrame {
pub samples: Tensor,
pub sample_rate: u32,
pub timestamp: Option<Timestamp>,
}
#[derive(Debug)]
pub enum MediaFrame {
Video(VideoFrame),
Audio(AudioFrame),
}
impl MediaFrame {
pub fn timestamp(&self) -> Option<Timestamp> {
match self {
Self::Video(v) => v.timestamp,
Self::Audio(a) => a.timestamp,
}
}
}
impl MemoryFootprint for VideoFrame {
fn resident_bytes(&self) -> usize {
self.pixels.resident_bytes()
}
}
impl MemoryFootprint for AudioFrame {
fn resident_bytes(&self) -> usize {
self.samples.resident_bytes()
}
}
impl MemoryFootprint for MediaFrame {
fn resident_bytes(&self) -> usize {
match self {
Self::Video(v) => v.resident_bytes(),
Self::Audio(a) => a.resident_bytes(),
}
}
}
impl PinMemory for VideoFrame {
fn pin_memory(mut self, d: Device) -> rusttorch_core::Result<Self> {
self.pixels = self.pixels.pin_memory(d)?;
Ok(self)
}
}
impl PinMemory for AudioFrame {
fn pin_memory(mut self, d: Device) -> rusttorch_core::Result<Self> {
self.samples = self.samples.pin_memory(d)?;
Ok(self)
}
}
impl PinMemory for MediaFrame {
fn pin_memory(self, d: Device) -> rusttorch_core::Result<Self> {
match self {
Self::Video(v) => Ok(Self::Video(v.pin_memory(d)?)),
Self::Audio(a) => Ok(Self::Audio(a.pin_memory(d)?)),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamInfo {
pub index: usize,
pub kind: StreamKind,
pub time_base: TimeBase,
pub duration: Option<i64>,
pub decoder: String,
}
#[derive(Clone, Debug)]
pub struct CodecCapabilities {
pub version: String,
pub configuration: String,
pub license: String,
pub cpu_decode: bool,
}
#[cfg(any(feature = "system", feature = "vcpkg"))]
mod native;
#[cfg(any(feature = "system", feature = "vcpkg"))]
pub use native::{MediaDecoder, capabilities};