use std::io::{self, BufReader, Read};
use crate::error::{Error, Result};
use crate::util::bytes::Reader;
pub mod id {
pub const EBML: u32 = 0x1A45_DFA3;
pub const EBML_READ_VERSION: u32 = 0x42F7;
pub const EBML_MAX_ID_LENGTH: u32 = 0x42F2;
pub const EBML_MAX_SIZE_LENGTH: u32 = 0x42F3;
pub const DOC_TYPE: u32 = 0x4282;
pub const DOC_TYPE_READ_VERSION: u32 = 0x4285;
pub const VOID: u32 = 0xEC;
pub const CRC32: u32 = 0xBF;
pub const SEGMENT: u32 = 0x1853_8067;
pub const SEEK_HEAD: u32 = 0x114D_9B74;
pub const INFO: u32 = 0x1549_A966;
pub const TIMESTAMP_SCALE: u32 = 0x2A_D7B1;
pub const TRACKS: u32 = 0x1654_AE6B;
pub const TRACK_ENTRY: u32 = 0xAE;
pub const TRACK_NUMBER: u32 = 0xD7;
pub const TRACK_TYPE: u32 = 0x83;
pub const CODEC_ID: u32 = 0x86;
pub const CODEC_PRIVATE: u32 = 0x63A2;
pub const CODEC_DELAY: u32 = 0x56AA;
pub const DEFAULT_DURATION: u32 = 0x23_E383;
pub const TRACK_TIMESTAMP_SCALE: u32 = 0x23_314F;
pub const CONTENT_ENCODINGS: u32 = 0x6D80;
pub const VIDEO: u32 = 0xE0;
pub const PIXEL_WIDTH: u32 = 0xB0;
pub const PIXEL_HEIGHT: u32 = 0xBA;
pub const AUDIO: u32 = 0xE1;
pub const SAMPLING_FREQUENCY: u32 = 0xB5;
pub const CHANNELS: u32 = 0x9F;
pub const BIT_DEPTH: u32 = 0x6264;
pub const CLUSTER: u32 = 0x1F43_B675;
pub const CLUSTER_TIMESTAMP: u32 = 0xE7;
pub const SIMPLE_BLOCK: u32 = 0xA3;
pub const BLOCK_GROUP: u32 = 0xA0;
pub const BLOCK: u32 = 0xA1;
pub const BLOCK_DURATION: u32 = 0x9B;
pub const REFERENCE_BLOCK: u32 = 0xFB;
}
const MAX_HEADER_SIZE: u64 = 16 << 20;
const MAX_BLOCK_SIZE: u64 = 64 << 20;
const MAX_SKIP_SIZE: u64 = 1 << 30;
const MAX_LACED_FRAMES: usize = 256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TrackType {
Video,
Audio,
Other(u64),
}
#[derive(Debug, Clone, PartialEq)]
pub struct Track {
pub number: u64,
pub track_type: TrackType,
pub codec_id: String,
pub codec_private: Vec<u8>,
pub codec_delay_ns: u64,
pub default_duration_ns: Option<u64>,
pub timestamp_scale: f64,
pub pixel_width: Option<u32>,
pub pixel_height: Option<u32>,
pub sampling_frequency: Option<f64>,
pub channels: Option<u8>,
pub bit_depth: Option<u8>,
}
impl Track {
fn new() -> Track {
Track {
number: 0,
track_type: TrackType::Other(0),
codec_id: String::new(),
codec_private: Vec::new(),
codec_delay_ns: 0,
default_duration_ns: None,
timestamp_scale: 1.0,
pixel_width: None,
pixel_height: None,
sampling_frequency: None,
channels: None,
bit_depth: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Frame {
pub track: u64,
pub timestamp: i64,
pub pts_ns: i64,
pub keyframe: bool,
pub duration: Option<u64>,
pub data: Vec<u8>,
}
struct Input<R> {
inner: R,
pos: u64,
}
impl<R: Read> Input<R> {
fn byte(&mut self) -> Result<Option<u8>> {
let mut b = [0u8];
loop {
match self.inner.read(&mut b) {
Ok(0) => return Ok(None),
Ok(_) => {
self.pos += 1;
return Ok(Some(b[0]));
}
Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
Err(e) => return Err(Error::io("mkv: read", e)),
}
}
}
fn exact(&mut self, buf: &mut [u8]) -> Result<()> {
self.inner.read_exact(buf).map_err(|e| {
if e.kind() == io::ErrorKind::UnexpectedEof {
Error::malformed(format!("mkv: truncated element at offset {}", self.pos))
} else {
Error::io("mkv: read", e)
}
})?;
self.pos += buf.len() as u64;
Ok(())
}
fn take(&mut self, n: u64) -> Result<Vec<u8>> {
let mut buf = vec![0u8; n as usize];
self.exact(&mut buf)?;
Ok(buf)
}
fn skip(&mut self, mut n: u64) -> Result<()> {
let mut buf = [0u8; 8192];
while n > 0 {
let chunk = n.min(buf.len() as u64) as usize;
self.exact(&mut buf[..chunk])?;
n -= chunk as u64;
}
Ok(())
}
fn vint_rest(&mut self, first: u8, max_len: u32) -> Result<(u32, u64, bool)> {
let len = first.leading_zeros() + 1;
if len > max_len {
return Err(Error::malformed(format!(
"mkv: invalid variable-size integer at offset {}",
self.pos
)));
}
let mut v = (first as u64) & (0xff >> len);
let mut all_ones = v == (0xff >> len);
for _ in 1..len {
let b = self.byte()?.ok_or_else(|| {
Error::malformed(format!(
"mkv: truncated element header at offset {}",
self.pos
))
})?;
all_ones &= b == 0xff;
v = (v << 8) | b as u64;
}
Ok((len, v, all_ones))
}
fn header(&mut self) -> Result<Option<Header>> {
let Some(first) = self.byte()? else {
return Ok(None);
};
let (len, raw, _) = self.vint_rest(first, 4)?;
let id = (raw | (1u64 << (7 * len))) as u32;
let Some(first) = self.byte()? else {
return Err(Error::malformed("mkv: truncated element header"));
};
let (_, size, all_ones) = self.vint_rest(first, 8)?;
Ok(Some(Header {
id,
size: if all_ones { None } else { Some(size) },
}))
}
}
#[derive(Debug, Clone, Copy)]
struct Header {
id: u32,
size: Option<u64>,
}
impl Header {
fn known(&self, limit: u64) -> Result<u64> {
match self.size {
Some(n) if n <= limit => Ok(n),
Some(n) => Err(Error::malformed(format!(
"mkv: element {:#x} too large ({} bytes)",
self.id, n
))),
None => Err(Error::malformed(format!(
"mkv: element {:#x} has unknown size",
self.id
))),
}
}
}
fn buf_vint(r: &mut Reader<'_>) -> Result<(u32, u64)> {
let first = r.u8()?;
let len = first.leading_zeros() + 1;
if len > 8 {
return Err(r.error("invalid variable-size integer"));
}
let mut v = (first as u64) & (0xff >> len);
for _ in 1..len {
v = (v << 8) | r.u8()? as u64;
}
Ok((len, v))
}
fn children<'a>(data: &'a [u8]) -> impl Iterator<Item = Result<(u32, &'a [u8])>> + 'a {
let mut r = Reader::new(data, "mkv");
let mut failed = false;
std::iter::from_fn(move || {
if failed || r.is_at_end() {
return None;
}
let rv = (|| {
let (len, raw) = buf_vint(&mut r)?;
if len > 4 {
return Err(r.error("invalid element ID"));
}
let id = (raw | (1u64 << (7 * len))) as u32;
let (slen, size) = buf_vint(&mut r)?;
if size == (1u64 << (7 * slen)) - 1 {
return Err(r.error("unknown size inside a sized element"));
}
let size = usize::try_from(size).map_err(|_| r.error("element too large"))?;
Ok((id, r.bytes(size)?))
})();
failed = rv.is_err();
Some(rv)
})
}
fn uint(data: &[u8]) -> Result<u64> {
if data.len() > 8 {
return Err(Error::malformed("mkv: unsigned integer wider than 8 bytes"));
}
Ok(data.iter().fold(0u64, |a, &b| (a << 8) | b as u64))
}
fn float(data: &[u8]) -> Result<f64> {
match data.len() {
0 => Ok(0.0),
4 => Ok(f32::from_be_bytes([data[0], data[1], data[2], data[3]]) as f64),
8 => {
let mut b = [0u8; 8];
b.copy_from_slice(data);
Ok(f64::from_be_bytes(b))
}
_ => Err(Error::malformed("mkv: float must be 0, 4 or 8 bytes")),
}
}
fn string(data: &[u8]) -> Result<String> {
let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
std::str::from_utf8(&data[..end])
.map(str::to_owned)
.map_err(|_| Error::malformed("mkv: invalid UTF-8 string"))
}
fn parse_ebml_header(body: &[u8]) -> Result<()> {
let mut doc_type = String::from("matroska");
for child in children(body) {
let (id, data) = child?;
match id {
id::DOC_TYPE => doc_type = string(data)?,
id::EBML_READ_VERSION if uint(data)? > 1 => {
return Err(Error::unsupported("mkv: EBMLReadVersion > 1"));
}
id::EBML_MAX_ID_LENGTH if uint(data)? > 4 => {
return Err(Error::unsupported("mkv: EBMLMaxIDLength > 4"));
}
id::EBML_MAX_SIZE_LENGTH if uint(data)? > 8 => {
return Err(Error::unsupported("mkv: EBMLMaxSizeLength > 8"));
}
id::DOC_TYPE_READ_VERSION if uint(data)? > 4 => {
return Err(Error::unsupported("mkv: DocTypeReadVersion > 4"));
}
_ => {}
}
}
if doc_type != "matroska" && doc_type != "webm" {
return Err(Error::unsupported(format!(
"mkv: unsupported DocType {doc_type:?}"
)));
}
Ok(())
}
fn parse_track(body: &[u8]) -> Result<Track> {
let mut t = Track::new();
let mut have_type = false;
for child in children(body) {
let (id, data) = child?;
match id {
id::TRACK_NUMBER => t.number = uint(data)?,
id::TRACK_TYPE => {
have_type = true;
t.track_type = match uint(data)? {
1 => TrackType::Video,
2 => TrackType::Audio,
n => TrackType::Other(n),
}
}
id::CODEC_ID => t.codec_id = string(data)?,
id::CODEC_PRIVATE => t.codec_private = data.to_vec(),
id::CODEC_DELAY => t.codec_delay_ns = uint(data)?,
id::DEFAULT_DURATION => t.default_duration_ns = Some(uint(data)?),
id::TRACK_TIMESTAMP_SCALE => {
let s = float(data)?;
if !(s.is_finite() && s > 0.0) {
return Err(Error::malformed("mkv: invalid TrackTimestampScale"));
}
t.timestamp_scale = s;
}
id::CONTENT_ENCODINGS => {
return Err(Error::unsupported(
"mkv: tracks with ContentEncodings (compression/encryption) are not supported",
));
}
id::VIDEO => {
for child in children(data) {
let (id, data) = child?;
let v = uint(data).ok().and_then(|v| u32::try_from(v).ok());
match id {
id::PIXEL_WIDTH => t.pixel_width = v,
id::PIXEL_HEIGHT => t.pixel_height = v,
_ => {}
}
}
}
id::AUDIO => {
for child in children(data) {
let (id, data) = child?;
match id {
id::SAMPLING_FREQUENCY => t.sampling_frequency = Some(float(data)?),
id::CHANNELS => t.channels = u8::try_from(uint(data)?).ok(),
id::BIT_DEPTH => t.bit_depth = u8::try_from(uint(data)?).ok(),
_ => {}
}
}
}
_ => {}
}
}
if t.number == 0 || !have_type || t.codec_id.is_empty() {
return Err(Error::malformed(
"mkv: TrackEntry without TrackNumber, TrackType or CodecID",
));
}
Ok(t)
}
fn unlace(lacing: u8, r: &mut Reader<'_>) -> Result<Vec<Vec<u8>>> {
if lacing == 0 {
return Ok(vec![r.rest().to_vec()]);
}
let count = r.u8()? as usize + 1;
if count > MAX_LACED_FRAMES {
return Err(r.error("too many laced frames"));
}
let mut sizes = Vec::with_capacity(count);
match lacing {
1 => {
for _ in 0..count - 1 {
let mut size = 0usize;
loop {
let b = r.u8()?;
size += b as usize;
if b != 255 {
break;
}
}
sizes.push(size);
}
}
3 if count > 1 => {
let (_, first) = buf_vint(r)?;
let mut prev = i64::try_from(first).map_err(|_| r.error("lace size too large"))?;
sizes.push(prev as usize);
for _ in 1..count - 1 {
let (len, raw) = buf_vint(r)?;
let bias = (1i64 << (7 * len - 1)) - 1;
prev = prev
.checked_add(raw as i64 - bias)
.filter(|&s| s >= 0)
.ok_or_else(|| r.error("invalid EBML lace size"))?;
sizes.push(prev as usize);
}
}
3 => {}
2 => {
let rest = r.remaining();
if rest % count != 0 {
return Err(r.error("fixed lacing size not divisible by frame count"));
}
sizes = vec![rest / count; count - 1];
}
_ => return Err(r.error("invalid lacing mode")),
}
let total: usize = sizes
.iter()
.try_fold(0usize, |a, &s| a.checked_add(s))
.ok_or_else(|| r.error("lace sizes overflow"))?;
if total > r.remaining() {
return Err(r.error("lace sizes exceed block size"));
}
let mut frames = Vec::with_capacity(count);
for size in sizes {
frames.push(r.bytes(size)?.to_vec());
}
frames.push(r.rest().to_vec());
Ok(frames)
}
pub struct Demuxer<R> {
input: Input<BufReader<R>>,
timestamp_scale: u64,
tracks: Vec<Track>,
cluster_timestamp: Option<u64>,
pending: std::collections::VecDeque<Frame>,
in_cluster: bool,
}
impl<R: Read> Demuxer<R> {
pub fn new(inner: R) -> Result<Demuxer<R>> {
let mut d = Demuxer {
input: Input {
inner: BufReader::with_capacity(64 * 1024, inner),
pos: 0,
},
timestamp_scale: 1_000_000,
tracks: Vec::new(),
cluster_timestamp: None,
pending: Default::default(),
in_cluster: false,
};
let h = d
.input
.header()?
.ok_or_else(|| Error::malformed("mkv: empty input"))?;
if h.id != id::EBML {
return Err(Error::malformed("mkv: missing EBML header"));
}
let body = d.input.take(h.known(MAX_HEADER_SIZE)?)?;
parse_ebml_header(&body)?;
loop {
let h = d
.input
.header()?
.ok_or_else(|| Error::malformed("mkv: no Tracks before end of input"))?;
match h.id {
id::SEGMENT => {}
id::INFO => {
let body = d.input.take(h.known(MAX_HEADER_SIZE)?)?;
d.parse_info(&body)?;
}
id::TRACKS => {
let body = d.input.take(h.known(MAX_HEADER_SIZE)?)?;
d.parse_tracks(&body)?;
}
id::CLUSTER => {
if d.tracks.is_empty() {
return Err(Error::malformed("mkv: Cluster before Tracks"));
}
d.in_cluster = true;
return Ok(d);
}
_ => d.skip(h)?,
}
}
}
pub fn tracks(&self) -> &[Track] {
&self.tracks
}
pub fn track(&self, number: u64) -> Option<&Track> {
self.tracks.iter().find(|t| t.number == number)
}
pub fn timestamp_scale(&self) -> u64 {
self.timestamp_scale
}
pub fn position(&self) -> u64 {
self.input.pos
}
fn parse_info(&mut self, body: &[u8]) -> Result<()> {
for child in children(body) {
let (id, data) = child?;
if id == id::TIMESTAMP_SCALE {
let s = uint(data)?;
if s == 0 {
return Err(Error::malformed("mkv: TimestampScale is zero"));
}
self.timestamp_scale = s;
}
}
Ok(())
}
fn parse_tracks(&mut self, body: &[u8]) -> Result<()> {
for child in children(body) {
let (id, data) = child?;
if id == id::TRACK_ENTRY {
let t = parse_track(data)?;
if self.track(t.number).is_some() {
return Err(Error::malformed("mkv: duplicate TrackNumber"));
}
self.tracks.push(t);
}
}
if self.tracks.is_empty() {
return Err(Error::malformed("mkv: Tracks without TrackEntry"));
}
Ok(())
}
fn skip(&mut self, h: Header) -> Result<()> {
let n = h.known(MAX_SKIP_SIZE)?;
self.input.skip(n)
}
pub fn next_frame(&mut self) -> Result<Option<Frame>> {
loop {
if let Some(f) = self.pending.pop_front() {
return Ok(Some(f));
}
if self.in_cluster {
self.in_cluster = false;
self.cluster_timestamp = None;
}
let Some(h) = self.input.header()? else {
return Ok(None);
};
match h.id {
id::SEGMENT => {}
id::CLUSTER => self.cluster_timestamp = None,
id::CLUSTER_TIMESTAMP => {
let body = self.input.take(h.known(8)?)?;
self.cluster_timestamp = Some(uint(&body)?);
}
id::SIMPLE_BLOCK => {
let body = self.input.take(h.known(MAX_BLOCK_SIZE)?)?;
self.parse_block(&body, None, None)?;
}
id::BLOCK_GROUP => {
let body = self.input.take(h.known(MAX_BLOCK_SIZE)?)?;
self.parse_block_group(&body)?;
}
id::TRACKS => {
return Err(Error::unsupported("mkv: Tracks changed mid-stream"));
}
id::EBML => {
return Err(Error::unsupported("mkv: chained segments"));
}
_ => self.skip(h)?,
}
}
}
fn parse_block_group(&mut self, body: &[u8]) -> Result<()> {
let mut block = None;
let mut has_reference = false;
let mut duration = None;
for child in children(body) {
let (id, data) = child?;
match id {
id::BLOCK => block = Some(data),
id::REFERENCE_BLOCK => has_reference = true,
id::BLOCK_DURATION => duration = Some(uint(data)?),
_ => {}
}
}
let block = block.ok_or_else(|| Error::malformed("mkv: BlockGroup without Block"))?;
self.parse_block(block, Some(!has_reference), duration)
}
fn parse_block(
&mut self,
body: &[u8],
group_keyframe: Option<bool>,
duration: Option<u64>,
) -> Result<()> {
let mut r = Reader::new(body, "mkv block");
let (_, track) = buf_vint(&mut r)?;
let rel = r.i16_be()? as i64;
let flags = r.u8()?;
let Some(t) = self.track(track) else {
return Err(r.error("block for unknown track"));
};
let track_scale = t.timestamp_scale;
let default_duration = t.default_duration_ns;
let codec_delay = i64::try_from(t.codec_delay_ns).unwrap_or(i64::MAX);
let cluster = self
.cluster_timestamp
.ok_or_else(|| Error::malformed("mkv: block before cluster Timestamp"))?;
let cluster = i64::try_from(cluster).map_err(|_| r.error("cluster timestamp too large"))?;
let timestamp = cluster
.checked_add(rel)
.ok_or_else(|| r.error("timestamp overflow"))?;
let keyframe = group_keyframe.unwrap_or(flags & 0x80 != 0);
let frames = unlace((flags >> 1) & 0x03, &mut r)?;
let pts_ns = self
.ticks_to_ns(timestamp, track_scale)?
.saturating_sub(codec_delay);
for (i, data) in frames.into_iter().enumerate() {
let offset = default_duration.unwrap_or(0).saturating_mul(i as u64);
self.pending.push_back(Frame {
track,
timestamp,
pts_ns: pts_ns.saturating_add(offset as i64),
keyframe,
duration,
data,
});
}
Ok(())
}
pub fn ffprobe_pts(&self, f: &Frame) -> i64 {
let delay = self.track(f.track).map_or(0, |t| t.codec_delay_ns);
let scale = self.timestamp_scale;
let delay_ticks = (delay + scale / 2) / scale;
f.timestamp.saturating_sub(delay_ticks as i64)
}
fn ticks_to_ns(&self, ticks: i64, track_scale: f64) -> Result<i64> {
let ns = ticks as i128 * self.timestamp_scale as i128;
let ns = if track_scale == 1.0 {
ns
} else {
(ns as f64 * track_scale) as i128
};
i64::try_from(ns).map_err(|_| Error::malformed("mkv: timestamp out of range"))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::util::bytes::Writer;
fn el(w: &mut Writer, id: u32, body: &[u8]) {
let id_len = 4 - (id.leading_zeros() / 8) as usize;
w.uint_be(id as u64, id_len);
size(w, Some(body.len() as u64));
w.bytes(body);
}
fn size(w: &mut Writer, n: Option<u64>) {
match n {
None => {
w.u8(0x01).bytes(&[0xff; 7]);
}
Some(n) => {
w.u8(0x01).uint_be(n, 7);
}
}
}
fn uint_el(w: &mut Writer, id: u32, v: u64) {
el(w, id, &v.to_be_bytes());
}
fn header(tracks: &[(u64, u64, &str)]) -> Writer {
let mut w = Writer::new();
let mut ebml = Writer::new();
el(&mut ebml, id::DOC_TYPE, b"matroska");
el(&mut w, id::EBML, ebml.as_slice());
w.u32_be(id::SEGMENT);
size(&mut w, None);
let mut info = Writer::new();
uint_el(&mut info, id::TIMESTAMP_SCALE, 1_000_000);
el(&mut w, id::INFO, info.as_slice());
let mut tw = Writer::new();
for &(num, ty, codec) in tracks {
let mut t = Writer::new();
uint_el(&mut t, id::TRACK_NUMBER, num);
uint_el(&mut t, id::TRACK_TYPE, ty);
el(&mut t, id::CODEC_ID, codec.as_bytes());
uint_el(&mut t, id::DEFAULT_DURATION, 10_000_000);
el(&mut tw, id::TRACK_ENTRY, t.as_slice());
}
el(&mut w, id::TRACKS, tw.as_slice());
w
}
fn cluster(w: &mut Writer, ts: u64) {
w.u32_be(id::CLUSTER);
size(w, None);
uint_el(w, id::CLUSTER_TIMESTAMP, ts);
}
fn block(track: u8, rel: i16, flags: u8, payload: &[u8]) -> Vec<u8> {
let mut b = Writer::new();
b.u8(0x80 | track).i16_be(rel).u8(flags).bytes(payload);
b.into_vec()
}
#[test]
fn unknown_size_clusters_and_block_groups() {
let mut w = header(&[(1, 1, "V_MPEG4/ISO/AVC"), (2, 2, "A_OPUS")]);
cluster(&mut w, 1000);
el(&mut w, id::SIMPLE_BLOCK, &block(1, 0, 0x80, b"key"));
el(&mut w, id::VOID, &[0; 3]);
el(&mut w, id::SIMPLE_BLOCK, &block(2, -5, 0x80, b"aud"));
cluster(&mut w, 2000);
let mut g = Writer::new();
el(&mut g, id::BLOCK, &block(1, 33, 0, b"delta"));
uint_el(&mut g, id::REFERENCE_BLOCK, 1);
uint_el(&mut g, id::BLOCK_DURATION, 33);
el(&mut w, id::BLOCK_GROUP, g.as_slice());
let mut g = Writer::new();
el(&mut g, id::BLOCK, &block(1, 66, 0, b"idr"));
el(&mut w, id::BLOCK_GROUP, g.as_slice());
let data = w.into_vec();
let mut d = Demuxer::new(&data[..]).unwrap();
assert_eq!(d.tracks().len(), 2);
assert_eq!(d.track(2).unwrap().codec_id, "A_OPUS");
let f = d.next_frame().unwrap().unwrap();
assert_eq!((f.track, f.timestamp, f.keyframe), (1, 1000, true));
assert_eq!(f.pts_ns, 1_000_000_000);
assert_eq!(f.data, b"key");
let f = d.next_frame().unwrap().unwrap();
assert_eq!(
(f.track, f.timestamp, f.data.as_slice()),
(2, 995, &b"aud"[..])
);
let f = d.next_frame().unwrap().unwrap();
assert_eq!(
(f.timestamp, f.keyframe, f.duration),
(2033, false, Some(33))
);
let f = d.next_frame().unwrap().unwrap();
assert_eq!(
(f.timestamp, f.keyframe, f.data.as_slice()),
(2066, true, &b"idr"[..])
);
assert!(d.next_frame().unwrap().is_none());
}
#[test]
fn lacing_modes() {
let mut w = header(&[(1, 2, "A_OPUS")]);
cluster(&mut w, 0);
let mut p = vec![2u8, 255, 45, 2];
p.extend(vec![b'a'; 300]);
p.extend(b"bbc");
el(&mut w, id::SIMPLE_BLOCK, &block(1, 0, 0x80 | 0x02, &p));
let mut p = vec![2u8, 0x83, 0xc1];
p.extend(b"xxxyyyyyzzzz");
el(&mut w, id::SIMPLE_BLOCK, &block(1, 30, 0x80 | 0x06, &p));
let mut p = vec![2u8];
p.extend(b"112233");
el(&mut w, id::SIMPLE_BLOCK, &block(1, 60, 0x80 | 0x04, &p));
let data = w.into_vec();
let mut d = Demuxer::new(&data[..]).unwrap();
let mut got = Vec::new();
while let Some(f) = d.next_frame().unwrap() {
got.push((f.timestamp, f.pts_ns / 1_000_000, f.data));
}
let sizes: Vec<usize> = got.iter().map(|g| g.2.len()).collect();
assert_eq!(sizes, [300, 2, 1, 3, 5, 4, 2, 2, 2]);
assert_eq!(got[4].2, b"yyyyy");
assert_eq!(got[8].2, b"33");
assert_eq!((got[1].0, got[1].1), (0, 10));
assert_eq!((got[5].0, got[5].1), (30, 50));
}
fn check_fixture(name: &str) {
let blocks = crate::util::vectors::load(&format!("mkv/{name}.txt"));
let b = &blocks[0];
let expected: Vec<String> = b
.str("packets")
.split(';')
.filter(|p| !p.is_empty())
.map(|p| p.replace(' ', ""))
.collect();
let data = crate::util::vectors::fixture(&format!("media/{name}.mkv"));
let mut d = Demuxer::new(&data[..]).unwrap();
let codecs: Vec<&str> = d.tracks().iter().map(|t| t.codec_id.as_str()).collect();
assert_eq!(codecs, ["V_MPEG4/ISO/AVC", "A_ALAC", "A_OPUS"]);
assert_eq!(b.str("stream0"), "h264");
let v = d.track(1).unwrap();
assert_eq!((v.pixel_width, v.pixel_height), (Some(160), Some(120)));
let a = d.track(2).unwrap();
assert_eq!((a.sampling_frequency, a.channels), (Some(44100.0), Some(2)));
assert_eq!(a.codec_private.len(), 24);
let o = d.track(3).unwrap();
assert!(o.codec_private.starts_with(b"OpusHead"));
let mut got = Vec::new();
while let Some(f) = d.next_frame().unwrap() {
got.push(format!(
"{}{}{}{}",
f.track - 1,
d.ffprobe_pts(&f),
if f.keyframe { "K" } else { "_" },
f.data.len()
));
}
assert_eq!(got.len(), expected.len(), "{name}: packet count");
for (i, (g, e)) in got.iter().zip(&expected).enumerate() {
assert_eq!(g, e, "{name}: packet {i}");
}
assert_eq!(d.position(), data.len() as u64);
}
#[test]
fn ffmpeg_live_fixture() {
check_fixture("live");
}
#[test]
fn ffmpeg_file_fixture() {
check_fixture("file");
}
#[test]
fn errors_not_panics() {
let mut w = header(&[(1, 1, "V_MPEG4/ISO/AVC")]);
cluster(&mut w, 0);
el(&mut w, id::SIMPLE_BLOCK, &block(1, 0, 0x80, b"frame"));
let data = w.into_vec();
for n in 0..data.len() {
if let Ok(mut d) = Demuxer::new(&data[..n]) {
while let Ok(Some(_)) = d.next_frame() {}
}
}
for i in 0..data.len() {
let mut bad = data.clone();
bad[i] ^= 0xff;
if let Ok(mut d) = Demuxer::new(&bad[..]) {
for _ in 0..16 {
if !matches!(d.next_frame(), Ok(Some(_))) {
break;
}
}
}
}
let mut w = header(&[(1, 1, "V_MPEG4/ISO/AVC")]);
cluster(&mut w, 0);
el(&mut w, id::SIMPLE_BLOCK, &block(7, 0, 0x80, b"x"));
let data = w.into_vec();
let mut d = Demuxer::new(&data[..]).unwrap();
assert!(d.next_frame().is_err());
let mut w = header(&[(1, 2, "A_OPUS")]);
cluster(&mut w, 0);
el(&mut w, id::SIMPLE_BLOCK, &block(1, 0, 0x82, &[1, 200, 1]));
let data = w.into_vec();
let mut d = Demuxer::new(&data[..]).unwrap();
assert!(d.next_frame().is_err());
assert!(Demuxer::new(&b"not mkv at all"[..]).is_err());
assert!(Demuxer::new(&[][..]).is_err());
}
}