#![allow(clippy::needless_range_loop)]
pub mod bits;
#[cfg(feature = "decode")]
pub mod cabac;
pub mod h264;
pub mod hevc;
#[cfg(feature = "decode")]
pub mod av1;
#[cfg(feature = "decode")]
pub mod vp9;
pub mod vp9_packet;
#[cfg(feature = "decode")]
pub mod picture;
#[cfg(feature = "decode")]
pub mod platform;
#[cfg(feature = "decode")]
pub use h264::H264Decoder;
#[cfg(feature = "decode")]
pub use hevc::HevcDecoder;
#[cfg(feature = "decode")]
pub use picture::{ChromaFormat, ColorInfo, DecodedFrame, Matrix, Plane};
#[cfg(feature = "decode")]
pub use platform::{Backend, Decoder};
#[cfg(feature = "decode")]
use crate::mp4_demux::{TrackCodec, VideoTrack};
#[cfg(feature = "decode")]
enum Codec {
H264(Box<H264Decoder>),
Hevc(Box<HevcDecoder>),
Vp9(Box<vp9::Vp9Decoder>),
Av1(Box<av1::Av1Decoder>),
}
#[cfg(feature = "decode")]
impl Codec {
fn decode_nal(&mut self, nal: &[u8]) -> Result<(), String> {
match self {
Codec::H264(d) => d.decode_nal(nal),
Codec::Hevc(d) => d.decode_nal(nal),
Codec::Vp9(_) => Err("VP9 has no NAL units".into()),
Codec::Av1(_) => Err("AV1 has no NAL units".into()),
}
}
fn flush(&mut self) -> Vec<DecodedFrame> {
match self {
Codec::H264(d) => {
d.finish_picture();
d.take_pictures().into_iter().map(|p| p.frame).collect()
}
Codec::Hevc(d) => {
d.finish_picture();
d.take_pictures().into_iter().map(|p| p.frame).collect()
}
Codec::Vp9(_) | Codec::Av1(_) => Vec::new(),
}
}
}
#[cfg(feature = "decode")]
pub(crate) fn split_avcc(cfg: &[u8]) -> Result<(Vec<&[u8]>, usize), String> {
if cfg.len() < 7 {
return Err("avcC too short".into());
}
let nal_len = (cfg[4] & 3) as usize + 1;
let mut sets = Vec::new();
let mut at = 5;
for pass in 0..2 {
let count = if pass == 0 {
(cfg[at] & 31) as usize
} else {
cfg.get(at).copied().unwrap_or(0) as usize
};
at += 1;
for _ in 0..count {
if at + 2 > cfg.len() {
return Err("avcC ended inside a parameter set".into());
}
let len = u16::from_be_bytes([cfg[at], cfg[at + 1]]) as usize;
at += 2;
if at + len > cfg.len() {
return Err("avcC parameter set runs past the box".into());
}
sets.push(&cfg[at..at + len]);
at += len;
}
if at >= cfg.len() {
break;
}
}
Ok((sets, nal_len))
}
#[cfg(feature = "decode")]
pub(crate) fn split_hvcc(cfg: &[u8]) -> Result<(Vec<&[u8]>, usize), String> {
if cfg.len() < 23 {
return Err("hvcC too short".into());
}
let nal_len = (cfg[21] & 3) as usize + 1;
let arrays = cfg[22] as usize;
let mut sets = Vec::new();
let mut at = 23;
for _ in 0..arrays {
if at + 3 > cfg.len() {
return Err("hvcC ended inside an array header".into());
}
let count = u16::from_be_bytes([cfg[at + 1], cfg[at + 2]]) as usize;
at += 3;
for _ in 0..count {
if at + 2 > cfg.len() {
return Err("hvcC ended inside a parameter set".into());
}
let len = u16::from_be_bytes([cfg[at], cfg[at + 1]]) as usize;
at += 2;
if at + len > cfg.len() {
return Err("hvcC parameter set runs past the box".into());
}
sets.push(&cfg[at..at + len]);
at += len;
}
}
Ok((sets, nal_len))
}
#[cfg(feature = "decode")]
pub struct NativeDecoder {
codec: Codec,
nal_len: usize,
width: u32,
height: u32,
ready: Vec<(i64, DecodedFrame)>,
}
#[cfg(feature = "decode")]
impl NativeDecoder {
pub fn new(track: &VideoTrack) -> Result<Self, String> {
Self::from_config(track.codec, &track.config, track.width, track.height)
}
pub fn from_config(codec: TrackCodec, config: &[u8], width: u32, height: u32) -> Result<Self, String> {
let (mut codec, (sets, nal_len)) = match codec {
TrackCodec::H264 => (
Codec::H264(Box::default()),
split_avcc(config)?,
),
TrackCodec::Hevc => (
Codec::Hevc(Box::default()),
split_hvcc(config)?,
),
TrackCodec::Vp9 => (Codec::Vp9(Box::default()), (Vec::new(), 0)),
TrackCodec::Av1 => (Codec::Av1(Box::default()), (Vec::new(), 0)),
};
for nal in sets {
codec.decode_nal(nal)?;
}
Ok(NativeDecoder {
codec,
nal_len,
width,
height,
ready: Vec::new(),
})
}
pub fn size(&self) -> (u32, u32) {
(self.width, self.height)
}
pub fn push(&mut self, sample: &[u8], pts: i64, _dts: i64, _duration: i64) -> Result<(), String> {
if let Codec::Av1(d) = &mut self.codec {
for (i, f) in d.decode(sample)?.into_iter().enumerate() {
self.ready.push((pts + i as i64, f.to_decoded()));
}
return Ok(());
}
if let Codec::Vp9(d) = &mut self.codec {
for (i, f) in d.decode(sample)?.into_iter().enumerate() {
self.ready.push((pts + i as i64, f.to_decoded()?));
}
return Ok(());
}
for nal in bits::split_length_prefixed(sample, self.nal_len)? {
self.codec.decode_nal(nal)?;
}
for (i, frame) in self.codec.flush().into_iter().enumerate() {
self.ready.push((pts + i as i64, frame));
}
Ok(())
}
pub fn take(&mut self, pts: i64) -> Option<Vec<u8>> {
self.take_frame(pts).map(|f| f.to_bgra())
}
pub fn take_frame(&mut self, pts: i64) -> Option<DecodedFrame> {
let hit = self.ready.iter().position(|(p, _)| *p == pts)?;
let (_, frame) = self.ready.remove(hit);
self.ready.retain(|(p, _)| *p > pts);
Some(frame)
}
pub fn queued(&self) -> usize {
self.ready.len()
}
}
#[cfg(feature = "decode")]
pub fn decode_annexb(codec: TrackCodec, stream: &[u8]) -> Result<Vec<DecodedFrame>, String> {
let mut pics: Vec<(bool, i32, DecodedFrame)> = Vec::new();
match codec {
TrackCodec::H264 => {
let mut d = H264Decoder::new();
for nal in bits::split_annexb(stream) {
d.decode_nal(nal)?;
}
d.finish_picture();
pics.extend(d.take_pictures().into_iter().map(|p| (p.idr, p.poc, p.frame)));
}
TrackCodec::Vp9 => return Err("VP9 is not an Annex B stream".into()),
TrackCodec::Av1 => return Err("AV1 is not an Annex B H.26x stream".into()),
TrackCodec::Hevc => {
let mut d = HevcDecoder::new();
for nal in bits::split_annexb(stream) {
d.decode_nal(nal)?;
}
d.flush_output();
let mut by_id: std::collections::HashMap<u64, DecodedFrame> =
d.take_pictures().into_iter().map(|p| (p.id, p.frame)).collect();
return Ok(d
.take_output_order()
.into_iter()
.filter_map(|id| by_id.remove(&id))
.collect());
}
}
let mut period = 0u32;
let mut keyed: Vec<((u32, i32), DecodedFrame)> = Vec::with_capacity(pics.len());
for (i, (starts, poc, frame)) in pics.into_iter().enumerate() {
if starts && i > 0 {
period += 1;
}
keyed.push(((period, poc), frame));
}
keyed.sort_by_key(|(k, _)| *k);
Ok(keyed.into_iter().map(|(_, f)| f).collect())
}