1#![allow(clippy::needless_range_loop)]
53
54pub mod bits;
55#[cfg(feature = "decode")]
56pub mod cabac;
57pub mod h264;
58pub mod hevc;
59#[cfg(feature = "decode")]
60pub mod av1;
61#[cfg(feature = "decode")]
62pub mod vp9;
63pub mod vp9_packet;
64#[cfg(feature = "decode")]
65pub mod picture;
66#[cfg(feature = "decode")]
67pub mod platform;
68
69#[cfg(feature = "decode")]
70pub use h264::H264Decoder;
71#[cfg(feature = "decode")]
72pub use hevc::HevcDecoder;
73#[cfg(feature = "decode")]
74pub use picture::{ChromaFormat, ColorInfo, DecodedFrame, Matrix, Plane};
75#[cfg(feature = "decode")]
76pub use platform::{Backend, Decoder};
77
78#[cfg(feature = "decode")]
79use crate::mp4_demux::{TrackCodec, VideoTrack};
80
81#[cfg(feature = "decode")]
82enum Codec {
83 H264(Box<H264Decoder>),
84 Hevc(Box<HevcDecoder>),
85 Vp9(Box<vp9::Vp9Decoder>),
86 Av1(Box<av1::Av1Decoder>),
87}
88
89#[cfg(feature = "decode")]
90impl Codec {
91 fn decode_nal(&mut self, nal: &[u8]) -> Result<(), String> {
92 match self {
93 Codec::H264(d) => d.decode_nal(nal),
94 Codec::Hevc(d) => d.decode_nal(nal),
95 Codec::Vp9(_) => Err("VP9 has no NAL units".into()),
96 Codec::Av1(_) => Err("AV1 has no NAL units".into()),
97 }
98 }
99
100 fn flush(&mut self) -> Vec<DecodedFrame> {
103 match self {
104 Codec::H264(d) => {
105 d.finish_picture();
106 d.take_pictures().into_iter().map(|p| p.frame).collect()
107 }
108 Codec::Hevc(d) => {
109 d.finish_picture();
110 d.take_pictures().into_iter().map(|p| p.frame).collect()
111 }
112 Codec::Vp9(_) | Codec::Av1(_) => Vec::new(),
113 }
114 }
115}
116
117#[cfg(feature = "decode")]
118pub(crate) fn split_avcc(cfg: &[u8]) -> Result<(Vec<&[u8]>, usize), String> {
120 if cfg.len() < 7 {
121 return Err("avcC too short".into());
122 }
123 let nal_len = (cfg[4] & 3) as usize + 1;
124 let mut sets = Vec::new();
125 let mut at = 5;
126 for pass in 0..2 {
127 let count = if pass == 0 {
128 (cfg[at] & 31) as usize
129 } else {
130 cfg.get(at).copied().unwrap_or(0) as usize
131 };
132 at += 1;
133 for _ in 0..count {
134 if at + 2 > cfg.len() {
135 return Err("avcC ended inside a parameter set".into());
136 }
137 let len = u16::from_be_bytes([cfg[at], cfg[at + 1]]) as usize;
138 at += 2;
139 if at + len > cfg.len() {
140 return Err("avcC parameter set runs past the box".into());
141 }
142 sets.push(&cfg[at..at + len]);
143 at += len;
144 }
145 if at >= cfg.len() {
146 break;
147 }
148 }
149 Ok((sets, nal_len))
150}
151
152#[cfg(feature = "decode")]
153pub(crate) fn split_hvcc(cfg: &[u8]) -> Result<(Vec<&[u8]>, usize), String> {
155 if cfg.len() < 23 {
156 return Err("hvcC too short".into());
157 }
158 let nal_len = (cfg[21] & 3) as usize + 1;
159 let arrays = cfg[22] as usize;
160 let mut sets = Vec::new();
161 let mut at = 23;
162 for _ in 0..arrays {
163 if at + 3 > cfg.len() {
164 return Err("hvcC ended inside an array header".into());
165 }
166 let count = u16::from_be_bytes([cfg[at + 1], cfg[at + 2]]) as usize;
167 at += 3;
168 for _ in 0..count {
169 if at + 2 > cfg.len() {
170 return Err("hvcC ended inside a parameter set".into());
171 }
172 let len = u16::from_be_bytes([cfg[at], cfg[at + 1]]) as usize;
173 at += 2;
174 if at + len > cfg.len() {
175 return Err("hvcC parameter set runs past the box".into());
176 }
177 sets.push(&cfg[at..at + len]);
178 at += len;
179 }
180 }
181 Ok((sets, nal_len))
182}
183
184#[cfg(feature = "decode")]
185pub struct NativeDecoder {
188 codec: Codec,
189 nal_len: usize,
190 width: u32,
191 height: u32,
192 ready: Vec<(i64, DecodedFrame)>,
193}
194
195#[cfg(feature = "decode")]
196impl NativeDecoder {
197 pub fn new(track: &VideoTrack) -> Result<Self, String> {
199 Self::from_config(track.codec, &track.config, track.width, track.height)
200 }
201
202 pub fn from_config(codec: TrackCodec, config: &[u8], width: u32, height: u32) -> Result<Self, String> {
208 let (mut codec, (sets, nal_len)) = match codec {
209 TrackCodec::H264 => (
210 Codec::H264(Box::default()),
211 split_avcc(config)?,
212 ),
213 TrackCodec::Hevc => (
214 Codec::Hevc(Box::default()),
215 split_hvcc(config)?,
216 ),
217 TrackCodec::Vp9 => (Codec::Vp9(Box::default()), (Vec::new(), 0)),
218 TrackCodec::Av1 => (Codec::Av1(Box::default()), (Vec::new(), 0)),
219 };
220 for nal in sets {
221 codec.decode_nal(nal)?;
222 }
223 Ok(NativeDecoder {
224 codec,
225 nal_len,
226 width,
227 height,
228 ready: Vec::new(),
229 })
230 }
231
232 pub fn size(&self) -> (u32, u32) {
234 (self.width, self.height)
235 }
236
237 pub fn push(&mut self, sample: &[u8], pts: i64, _dts: i64, _duration: i64) -> Result<(), String> {
242 if let Codec::Av1(d) = &mut self.codec {
243 for (i, f) in d.decode(sample)?.into_iter().enumerate() {
245 self.ready.push((pts + i as i64, f.to_decoded()));
246 }
247 return Ok(());
248 }
249 if let Codec::Vp9(d) = &mut self.codec {
250 for (i, f) in d.decode(sample)?.into_iter().enumerate() {
252 self.ready.push((pts + i as i64, f.to_decoded()?));
253 }
254 return Ok(());
255 }
256 for nal in bits::split_length_prefixed(sample, self.nal_len)? {
257 self.codec.decode_nal(nal)?;
258 }
259 for (i, frame) in self.codec.flush().into_iter().enumerate() {
260 self.ready.push((pts + i as i64, frame));
263 }
264 Ok(())
265 }
266
267 pub fn take(&mut self, pts: i64) -> Option<Vec<u8>> {
271 self.take_frame(pts).map(|f| f.to_bgra())
272 }
273
274 pub fn take_frame(&mut self, pts: i64) -> Option<DecodedFrame> {
276 let hit = self.ready.iter().position(|(p, _)| *p == pts)?;
277 let (_, frame) = self.ready.remove(hit);
278 self.ready.retain(|(p, _)| *p > pts);
279 Some(frame)
280 }
281
282 pub fn queued(&self) -> usize {
284 self.ready.len()
285 }
286}
287
288#[cfg(feature = "decode")]
289pub fn decode_annexb(codec: TrackCodec, stream: &[u8]) -> Result<Vec<DecodedFrame>, String> {
292 let mut pics: Vec<(bool, i32, DecodedFrame)> = Vec::new();
294 match codec {
295 TrackCodec::H264 => {
296 let mut d = H264Decoder::new();
297 for nal in bits::split_annexb(stream) {
298 d.decode_nal(nal)?;
299 }
300 d.finish_picture();
301 pics.extend(d.take_pictures().into_iter().map(|p| (p.idr, p.poc, p.frame)));
302 }
303 TrackCodec::Vp9 => return Err("VP9 is not an Annex B stream".into()),
304 TrackCodec::Av1 => return Err("AV1 is not an Annex B H.26x stream".into()),
305 TrackCodec::Hevc => {
306 let mut d = HevcDecoder::new();
309 for nal in bits::split_annexb(stream) {
310 d.decode_nal(nal)?;
311 }
312 d.flush_output();
313 let mut by_id: std::collections::HashMap<u64, DecodedFrame> =
314 d.take_pictures().into_iter().map(|p| (p.id, p.frame)).collect();
315 return Ok(d
316 .take_output_order()
317 .into_iter()
318 .filter_map(|id| by_id.remove(&id))
319 .collect());
320 }
321 }
322 let mut period = 0u32;
323 let mut keyed: Vec<((u32, i32), DecodedFrame)> = Vec::with_capacity(pics.len());
324 for (i, (starts, poc, frame)) in pics.into_iter().enumerate() {
325 if starts && i > 0 {
326 period += 1;
327 }
328 keyed.push(((period, poc), frame));
329 }
330 keyed.sort_by_key(|(k, _)| *k);
331 Ok(keyed.into_iter().map(|(_, f)| f).collect())
332}