#[cfg(feature = "decode")]
pub mod cabac_init;
#[cfg(feature = "decode")]
pub mod ctu;
#[cfg(feature = "decode")]
pub mod filters;
#[cfg(feature = "decode")]
pub mod inter;
#[cfg(feature = "decode")]
pub mod intra;
#[cfg(feature = "decode")]
pub mod mv;
#[cfg_attr(not(feature = "decode"), allow(dead_code))]
pub mod params;
#[cfg(feature = "decode")]
pub mod pic;
#[cfg_attr(not(feature = "decode"), allow(dead_code))]
pub mod tables;
#[cfg(feature = "decode")]
pub mod transform;
#[cfg(feature = "decode")]
use std::collections::BTreeMap;
#[cfg(feature = "decode")]
use std::sync::{Arc, Mutex};
#[cfg(feature = "decode")]
use self::ctu::{Carry, SliceDec};
#[cfg(feature = "decode")]
use self::params::{Pps, SliceHeader, SliceType, Sps};
#[cfg(feature = "decode")]
use self::pic::{Layout, MvField, PicState, SliceInfo};
#[cfg(feature = "decode")]
use super::bits::unescape;
#[cfg(feature = "decode")]
use super::jobs::{caught, Jobs, Slot};
#[cfg(feature = "decode")]
use super::picture::{ChromaFormat, ColorInfo, DecodedFrame, Plane};
#[cfg(feature = "decode")]
pub type Result<T> = std::result::Result<T, String>;
#[cfg(feature = "decode")]
#[derive(Debug, Clone)]
pub struct HevcPicture {
pub id: u64,
pub frame: DecodedFrame,
pub poc: i32,
pub new_sequence: bool,
}
#[cfg(feature = "decode")]
pub struct Motion {
pub mv: Vec<MvField>,
pub w4: usize,
pub ctb_slice: Vec<u16>,
pub slices: Vec<SliceInfo>,
pub log2_ctb: usize,
pub ctb_w: usize,
}
#[cfg(feature = "decode")]
pub(crate) struct RefData {
planes: Arc<[Plane; 3]>,
motion: Arc<Motion>,
}
#[cfg(feature = "decode")]
#[derive(Clone)]
pub struct RefPic {
pub poc: i32,
pub long_term: bool,
pub planes: Arc<[Plane; 3]>,
pub motion: Arc<Motion>,
size: (usize, usize),
pending: Option<Arc<Slot<RefData>>>,
}
#[cfg(feature = "decode")]
#[derive(Clone, Copy, Debug)]
pub struct RefEntry {
pub dpb: usize,
pub poc: i32,
pub long_term: bool,
}
#[cfg(feature = "decode")]
struct Current {
pic: PicState,
sps: Sps,
pps: Pps,
carry: Carry,
output: bool,
new_sequence: bool,
st_before: Vec<usize>,
st_after: Vec<usize>,
lt_curr: Vec<usize>,
work: Vec<SliceWork>,
}
#[cfg(feature = "decode")]
struct SliceWork {
rbsp: Vec<u8>,
sh: SliceHeader,
refs: [Vec<RefEntry>; 2],
slice_idx: u16,
slice_addr: u32,
}
#[cfg(feature = "decode")]
struct Threads {
jobs: Arc<Jobs>,
finished: Arc<Mutex<BTreeMap<u64, Option<HevcPicture>>>>,
error: Arc<Mutex<Option<(u64, String)>>>,
next_take: u64,
next_job: u64,
}
#[cfg(feature = "decode")]
pub trait HevcAccel {
fn slice(&mut self, s: &AccelSlice<'_>) -> Result<()>;
fn end_picture(&mut self) -> Result<()>;
fn frame(&mut self, poc: i32, sps: &Sps) -> Result<DecodedFrame>;
}
#[cfg(feature = "decode")]
pub struct AccelSlice<'a> {
pub nal: &'a [u8],
pub nal_type: u32,
pub sps: &'a Sps,
pub pps: &'a Pps,
pub sh: &'a SliceHeader,
pub first: bool,
pub poc: i32,
pub dpb: &'a [RefPic],
pub st_before: &'a [usize],
pub st_after: &'a [usize],
pub lt_curr: &'a [usize],
pub refs: &'a [Vec<RefEntry>; 2],
}
#[cfg(feature = "decode")]
pub struct HevcDecoder {
spss: Vec<Option<Sps>>,
ppss: Vec<Option<Pps>>,
dpb: Vec<RefPic>,
cur: Option<Current>,
last_header: Option<SliceHeader>,
prev_tid0_poc: i32,
at_start: bool,
skip_rasl: bool,
skipping: bool,
layout: Option<(usize, usize, Arc<Layout>)>,
done: Vec<HevcPicture>,
pending: Vec<(u64, i32, u32)>,
output: Vec<u64>,
next_id: u64,
decoded_any: bool,
accel: Option<Box<dyn HevcAccel>>,
accel_error: Option<String>,
accel_started: bool,
threads: Option<Threads>,
}
#[cfg(feature = "decode")]
impl Default for HevcDecoder {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "decode")]
impl HevcDecoder {
pub fn new() -> Self {
HevcDecoder {
spss: vec![None; 16],
ppss: vec![None; 64],
dpb: Vec::new(),
cur: None,
last_header: None,
prev_tid0_poc: 0,
at_start: true,
skip_rasl: false,
skipping: false,
layout: None,
done: Vec::new(),
pending: Vec::new(),
output: Vec::new(),
next_id: 0,
decoded_any: false,
accel: None,
accel_error: None,
accel_started: false,
threads: None,
}
}
pub fn set_threads(&mut self, threads: usize) {
if threads > 1 && self.accel.is_none() && crate::pool_can_serve_caller() {
self.threads = Some(Threads {
jobs: Jobs::new(threads * 2),
finished: Arc::default(),
error: Arc::default(),
next_take: 0,
next_job: 0,
});
}
}
pub fn take_thread_error(&mut self) -> Option<String> {
let t = self.threads.as_ref()?;
t.error.lock().unwrap().take().map(|e| e.1)
}
pub fn set_accel(&mut self, accel: Box<dyn HevcAccel>) {
self.accel = Some(accel);
}
pub fn take_accel_error(&mut self) -> Option<String> {
self.accel_error.take()
}
pub fn decode_nal(&mut self, nal: &[u8]) -> Result<()> {
if nal.len() < 2 {
return Ok(());
}
let nal_type = ((nal[0] >> 1) & 63) as u32;
let layer = (((nal[0] & 1) << 5) | (nal[1] >> 3)) as u32;
let tid = (nal[1] & 7).saturating_sub(1) as u32;
if layer > 0 {
return Ok(());
}
match nal_type {
0..=9 | 16..=21 => {
let rbsp = unescape(&nal[2..]);
self.decode_slice(nal, &rbsp, nal_type, tid)
}
33 => {
let sps = Sps::parse(&unescape(&nal[2..]))?;
let id = sps.id as usize;
self.spss[id] = Some(sps);
self.layout = None;
Ok(())
}
34 => {
let pps = Pps::parse(&unescape(&nal[2..]), &self.spss)?;
let id = pps.id as usize;
self.ppss[id] = Some(pps);
self.layout = None;
Ok(())
}
35 => {
self.finish_picture();
Ok(())
}
36 | 37 => {
self.finish_picture();
self.at_start = true;
Ok(())
}
_ => Ok(()),
}
}
pub fn take_output_order(&mut self) -> Vec<u64> {
std::mem::take(&mut self.output)
}
pub fn flush_output(&mut self) {
self.finish_picture();
while self.bump() {}
if let Some(t) = &self.threads {
t.jobs.wait();
}
}
fn bump(&mut self) -> bool {
let Some(i) = (0..self.pending.len()).min_by_key(|&i| self.pending[i].1) else {
return false;
};
let (id, _, _) = self.pending.remove(i);
self.output.push(id);
true
}
fn bump_while_over(&mut self, sps: &Sps, dpb_full: bool) {
loop {
let reorder = self.pending.len() > sps.max_num_reorder as usize;
let latency = sps.max_latency_increase_plus1 != 0 && {
let max = sps.max_num_reorder + sps.max_latency_increase_plus1 - 1;
self.pending.iter().any(|e| e.2 >= max)
};
let full = dpb_full && {
let refs = self
.dpb
.iter()
.filter(|p| !self.pending.iter().any(|e| e.1 == p.poc))
.count();
refs + self.pending.len() >= sps.max_dec_pic_buffering as usize
};
if !(reorder || latency || full) || !self.bump() {
return;
}
}
}
pub fn take_pictures(&mut self) -> Vec<HevcPicture> {
let finished = self.take_finished().into_iter().filter_map(|p| p.1);
let finished: Vec<_> = finished.collect();
self.done.extend(finished);
std::mem::take(&mut self.done)
}
pub(crate) fn take_finished(&mut self) -> Vec<(u64, Option<HevcPicture>)> {
let mut out = Vec::new();
if let Some(t) = &mut self.threads {
let mut finished = t.finished.lock().unwrap();
while let Some(picture) = finished.remove(&t.next_take) {
out.push((t.next_take, picture));
t.next_take += 1;
}
}
out
}
pub(crate) fn wait_for_pictures(&self) {
if let Some(t) = &self.threads {
t.jobs.wait();
}
}
pub(crate) fn threaded(&self) -> bool {
self.threads.is_some()
}
pub(crate) fn next_output_id(&self) -> u64 {
self.next_id
}
fn decode_slice(&mut self, nal: &[u8], rbsp: &[u8], nal_type: u32, tid: u32) -> Result<()> {
let first = rbsp.first().is_some_and(|b| b & 0x80 != 0);
if first {
self.finish_picture();
self.skipping = (nal_type == 8 || nal_type == 9) && self.skip_rasl;
self.last_header = None;
}
if self.skipping {
return Ok(());
}
if !first && self.cur.is_none() {
return Ok(());
}
let prev = self.last_header.as_ref();
let sh = SliceHeader::parse(rbsp, nal_type, &self.spss, &self.ppss, prev)?;
if first {
self.start_picture(&sh, nal_type, tid)?;
}
if !sh.dependent {
self.last_header = Some(sh.clone());
}
let refs = self.build_lists(&sh)?;
if let Some(accel) = self.accel.as_mut() {
let cur = self.cur.as_ref().unwrap();
let slice = AccelSlice {
nal,
nal_type,
sps: &cur.sps,
pps: &cur.pps,
sh: &sh,
first: !self.accel_started,
poc: cur.pic.poc,
dpb: &self.dpb,
st_before: &cur.st_before,
st_after: &cur.st_after,
lt_curr: &cur.lt_curr,
refs: &refs,
};
self.accel_started = true;
return accel.slice(&slice);
}
let cur = self.cur.as_mut().unwrap();
let slice_addr = if sh.dependent {
cur.pic.slices.last().map_or(0, |s| s.addr_rs)
} else {
sh.segment_address
};
let slice_idx = cur.pic.slices.len() as u16;
cur.pic.slices.push(SliceInfo {
addr_rs: slice_addr,
deblocking_disabled: sh.deblocking_disabled,
beta_offset: sh.beta_offset,
tc_offset: sh.tc_offset,
lf_across_slices: sh.loop_filter_across_slices,
cb_qp_offset: sh.cb_qp_offset,
cr_qp_offset: sh.cr_qp_offset,
refs: [
refs[0].iter().map(|e| (e.poc, e.long_term)).collect(),
refs[1].iter().map(|e| (e.poc, e.long_term)).collect(),
],
});
if self.threads.is_some() {
cur.work.push(SliceWork {
rbsp: rbsp.to_vec(),
sh,
refs,
slice_idx,
slice_addr,
});
return Ok(());
}
let mut dec = SliceDec::new(
&cur.sps,
&cur.pps,
&sh,
&mut cur.pic,
&self.dpb,
&refs,
&mut cur.carry,
slice_idx,
slice_addr,
);
dec.decode(rbsp)
}
fn start_picture(&mut self, sh: &SliceHeader, nal_type: u32, tid: u32) -> Result<()> {
let pps = self.ppss[sh.pps_id as usize].clone().ok_or("missing PPS")?;
let sps = self.spss[pps.sps_id as usize]
.clone()
.ok_or("missing SPS")?;
let layout = match &self.layout {
Some((s, p, l))
if *s == pps.sps_id as usize
&& *p == pps.id as usize
&& l.ctb_w == sps.width_ctbs() as usize
&& l.ctb_h == sps.height_ctbs() as usize =>
{
l.clone()
}
_ => {
let l = Arc::new(Layout::new(&sps, &pps));
self.layout = Some((pps.sps_id as usize, pps.id as usize, l.clone()));
l
}
};
if let Some(p) = self.dpb.first()
&& p.size != (sps.width as usize, sps.height as usize)
{
self.dpb.clear();
}
let irap = (16..=23).contains(&nal_type);
let idr = nal_type == 19 || nal_type == 20;
let no_rasl_output = irap && (idr || (16..=18).contains(&nal_type) || self.at_start);
if irap {
self.skip_rasl = no_rasl_output && !idr;
self.at_start = false;
}
let max_lsb = 1i32 << sps.log2_max_poc_lsb;
let lsb = sh.poc_lsb as i32;
let msb = if irap && no_rasl_output {
0
} else {
let prev_lsb = self.prev_tid0_poc & (max_lsb - 1);
let prev_msb = self.prev_tid0_poc - prev_lsb;
if lsb < prev_lsb && prev_lsb - lsb >= max_lsb / 2 {
prev_msb + max_lsb
} else if lsb > prev_lsb && lsb - prev_lsb > max_lsb / 2 {
prev_msb - max_lsb
} else {
prev_msb
}
};
let poc = msb + lsb;
let sub_layer_non_ref = nal_type < 16 && nal_type.is_multiple_of(2);
if tid == 0 && !(6..=9).contains(&nal_type) && !sub_layer_non_ref {
self.prev_tid0_poc = poc;
}
let mut st_before = Vec::new();
let mut st_after = Vec::new();
let mut lt_curr = Vec::new();
if idr || (irap && no_rasl_output) {
self.dpb.clear();
} else {
let mut keep = vec![false; self.dpb.len()];
let mut lt_mark = vec![false; self.dpb.len()];
let mut missing: Vec<(i32, bool, u8)> = Vec::new();
for &(v, msb_present, used) in &sh.lt {
let full = if msb_present {
v + poc - (poc & (max_lsb - 1))
} else {
v
};
let found = self.dpb.iter().position(|p| {
if msb_present {
p.poc == full
} else {
p.poc & (max_lsb - 1) == v
}
});
match found {
Some(i) => {
keep[i] = true;
lt_mark[i] = true;
if used {
lt_curr.push(i);
}
}
None if used => missing.push((full, true, 2)),
None => {}
}
}
for (list, entries) in [(0u8, &sh.st_rps.neg), (1u8, &sh.st_rps.pos)] {
for &(d, used) in entries {
let target = poc + d;
let found = self
.dpb
.iter()
.enumerate()
.position(|(i, p)| !lt_mark[i] && !p.long_term && p.poc == target);
match found {
Some(i) => {
keep[i] = true;
if used {
if list == 0 {
st_before.push(i);
} else {
st_after.push(i);
}
}
}
None if used => missing.push((target, false, list)),
None => {}
}
}
}
let mut remap = vec![usize::MAX; self.dpb.len()];
let mut kept = Vec::with_capacity(self.dpb.len());
for (i, p) in std::mem::take(&mut self.dpb).into_iter().enumerate() {
if keep[i] {
remap[i] = kept.len();
let mut p = p;
if lt_mark[i] {
p.long_term = true;
}
kept.push(p);
}
}
self.dpb = kept;
for v in [&mut st_before, &mut st_after, &mut lt_curr] {
for i in v.iter_mut() {
*i = remap[*i];
}
}
for (target, long_term, list) in missing {
let i = self.dpb.len();
self.dpb
.push(Self::placeholder(&sps, &layout, target, long_term));
match list {
0 => st_before.push(i),
1 => st_after.push(i),
_ => lt_curr.push(i),
}
}
}
if irap && no_rasl_output && self.decoded_any {
if nal_type == 21 || sh.no_output_of_prior_pics {
self.pending.clear();
} else {
while self.bump() {}
}
} else {
self.bump_while_over(&sps, true);
}
self.decoded_any = true;
let mut pic = if self.accel.is_some() || self.threads.is_some() {
PicState::sized(&sps, layout)
} else {
PicState::new(&sps, layout)
};
pic.poc = poc;
self.cur = Some(Current {
pic,
sps,
pps,
carry: Carry::default(),
output: sh.pic_output && !((8..=9).contains(&nal_type) && self.skip_rasl),
new_sequence: irap && no_rasl_output,
st_before,
st_after,
lt_curr,
work: Vec::new(),
});
Ok(())
}
fn placeholder(sps: &Sps, layout: &Layout, poc: i32, long_term: bool) -> RefPic {
let (w, h) = (sps.width as usize, sps.height as usize);
let planes = [
Plane::new(w, h, 1 << (sps.bit_depth_y - 1)),
Plane::new(w.div_ceil(2), h.div_ceil(2), 1 << (sps.bit_depth_c - 1)),
Plane::new(w.div_ceil(2), h.div_ceil(2), 1 << (sps.bit_depth_c - 1)),
];
RefPic {
poc,
long_term,
planes: Arc::new(planes),
motion: Arc::new(Motion {
mv: vec![MvField::INTRA; layout.w4 * layout.h4],
w4: layout.w4,
ctb_slice: vec![u16::MAX; layout.ctb_w * layout.ctb_h],
slices: Vec::new(),
log2_ctb: layout.log2_ctb as usize,
ctb_w: layout.ctb_w,
}),
size: (w, h),
pending: None,
}
}
fn build_lists(&self, sh: &SliceHeader) -> Result<[Vec<RefEntry>; 2]> {
let mut lists: [Vec<RefEntry>; 2] = [Vec::new(), Vec::new()];
if sh.slice_type == SliceType::I {
return Ok(lists);
}
let cur = self.cur.as_ref().unwrap();
let total = cur.st_before.len() + cur.st_after.len() + cur.lt_curr.len();
if total == 0 {
return Err("inter slice with no reference pictures".into());
}
let entry = |i: usize| RefEntry {
dpb: i,
poc: self.dpb[i].poc,
long_term: self.dpb[i].long_term,
};
for l in 0..(1 + (sh.slice_type == SliceType::B) as usize) {
let n = sh.num_ref_idx[l] as usize;
let order: Vec<usize> = if l == 0 {
cur.st_before
.iter()
.chain(&cur.st_after)
.chain(&cur.lt_curr)
.copied()
.collect()
} else {
cur.st_after
.iter()
.chain(&cur.st_before)
.chain(&cur.lt_curr)
.copied()
.collect()
};
let len = n.max(total);
let temp: Vec<usize> = (0..len).map(|k| order[k % total]).collect();
lists[l] = (0..n)
.map(|i| {
let k = match &sh.list_entry[l] {
Some(e) => e[i] as usize,
None => i,
};
temp.get(k)
.copied()
.map(entry)
.ok_or("list_entry out of range")
})
.collect::<std::result::Result<_, _>>()?;
}
Ok(lists)
}
pub fn finish_picture(&mut self) {
let Some(mut cur) = self.cur.take() else {
return;
};
if self.threads.is_some() {
self.submit_picture(cur);
return;
}
if let Some(accel) = self.accel.as_mut() {
if std::mem::take(&mut self.accel_started)
&& let Err(e) = accel.end_picture()
{
self.accel_error.get_or_insert(e);
}
} else {
filters::deblock(&mut cur.pic, &cur.sps, &cur.pps);
if cur.sps.sao {
filters::sao(&mut cur.pic, &cur.sps, &cur.pps);
}
}
let sps = &cur.sps;
let pic = cur.pic;
if cur.output {
let (fmt, crop, color) = output_format(sps);
let frame = match self.accel.as_mut() {
Some(a) => match a.frame(pic.poc, sps) {
Ok(f) => f,
Err(e) => {
self.accel_error.get_or_insert(e);
let grey =
|p: &Plane, bd: u32| Plane::new(p.width, p.height, 1 << (bd - 1));
let planes = [
grey(&pic.planes[0], sps.bit_depth_y),
grey(&pic.planes[1], sps.bit_depth_c),
grey(&pic.planes[2], sps.bit_depth_c),
];
DecodedFrame::from_planes(&planes, fmt, sps.bit_depth_y as u8, crop, color)
}
},
None => {
DecodedFrame::from_planes(&pic.planes, fmt, sps.bit_depth_y as u8, crop, color)
}
};
let id = self.next_id;
self.next_id += 1;
self.done.push(HevcPicture {
id,
frame,
poc: pic.poc,
new_sequence: cur.new_sequence,
});
for e in &mut self.pending {
e.2 += 1;
}
self.pending.push((id, pic.poc, 0));
self.bump_while_over(sps, false);
}
let layout = pic.layout.clone();
let size = (sps.width as usize, sps.height as usize);
let cap = (sps.max_dec_pic_buffering as usize).max(1) + 16;
let poc = pic.poc;
let data = ref_data(pic, &layout);
self.dpb.push(RefPic {
poc,
long_term: false,
planes: data.planes,
motion: data.motion,
size,
pending: None,
});
self.limit_dpb(cap);
}
fn limit_dpb(&mut self, cap: usize) {
while self.dpb.len() > cap {
self.dpb.remove(0);
}
}
fn submit_picture(&mut self, cur: Current) {
let poc = cur.pic.poc;
let out = cur.output.then(|| {
let id = self.next_id;
self.next_id += 1;
for e in &mut self.pending {
e.2 += 1;
}
self.pending.push((id, poc, 0));
self.bump_while_over(&cur.sps, false);
id
});
let dpb = self.dpb.clone();
let deps: Vec<_> = [&cur.st_before, &cur.st_after, &cur.lt_curr]
.into_iter()
.flatten()
.filter_map(|&i| dpb.get(i)?.pending.clone())
.collect();
let slot = Slot::new();
let size = (cur.sps.width as usize, cur.sps.height as usize);
let cap = (cur.sps.max_dec_pic_buffering as usize).max(1) + 16;
let layout = cur.pic.layout.clone();
let empty = Self::empty_ref(poc, size, slot.clone(), &layout);
self.dpb.push(empty);
self.limit_dpb(cap);
let t = self.threads.as_mut().unwrap();
let order = t.next_job;
t.next_job += 1;
let (finished, error) = (t.finished.clone(), t.error.clone());
let new_sequence = cur.new_sequence;
let sps = cur.sps.clone();
t.jobs.clone().submit(&deps, move || {
let result = caught(|| reconstruct(cur, dpb));
let (data, frame) = match result {
Ok((data, frame)) => (data, frame),
Err(e) => {
let mut first = error.lock().unwrap();
if first.as_ref().is_none_or(|f| order < f.0) {
*first = Some((order, e));
}
let grey = Self::placeholder(&sps, &layout, poc, false);
(
RefData {
planes: grey.planes,
motion: grey.motion,
},
None,
)
}
};
if let Some(id) = out {
let picture = frame.map(|frame| HevcPicture {
id,
frame,
poc,
new_sequence,
});
finished.lock().unwrap().insert(id, picture);
}
slot.finish(data);
});
}
fn empty_ref(
poc: i32,
size: (usize, usize),
slot: Arc<Slot<RefData>>,
layout: &Layout,
) -> RefPic {
let none = || Plane::new(0, 0, 0);
RefPic {
poc,
long_term: false,
planes: Arc::new([none(), none(), none()]),
motion: Arc::new(Motion {
mv: Vec::new(),
w4: layout.w4,
ctb_slice: Vec::new(),
slices: Vec::new(),
log2_ctb: layout.log2_ctb as usize,
ctb_w: layout.ctb_w,
}),
size,
pending: Some(slot),
}
}
}
#[cfg(feature = "decode")]
fn output_format(sps: &Sps) -> (ChromaFormat, [usize; 4], ColorInfo) {
let color = ColorInfo::from_vui(
sps.matrix_coefficients,
sps.full_range,
sps.height - sps.crop[2] - sps.crop[3],
);
let fmt = match sps.chroma_format_idc {
3 => ChromaFormat::Yuv444,
2 => ChromaFormat::Yuv422,
_ => ChromaFormat::Yuv420,
};
(fmt, sps.crop.map(|v| v as usize), color)
}
#[cfg(feature = "decode")]
fn ref_data(pic: PicState, layout: &Layout) -> RefData {
RefData {
planes: Arc::new(pic.planes),
motion: Arc::new(Motion {
mv: pic.mv,
w4: layout.w4,
ctb_slice: pic.ctb_slice,
slices: pic.slices,
log2_ctb: layout.log2_ctb as usize,
ctb_w: layout.ctb_w,
}),
}
}
#[cfg(feature = "decode")]
fn reconstruct(mut cur: Current, mut dpb: Vec<RefPic>) -> Result<(RefData, Option<DecodedFrame>)> {
for p in &mut dpb {
if let Some(data) = p.pending.as_ref().and_then(|s| s.get()) {
p.planes = data.planes.clone();
p.motion = data.motion.clone();
}
}
let mut pic = PicState::new(&cur.sps, cur.pic.layout.clone());
pic.poc = cur.pic.poc;
pic.slices = std::mem::take(&mut cur.pic.slices);
cur.pic = pic;
for w in std::mem::take(&mut cur.work) {
let mut dec = SliceDec::new(
&cur.sps,
&cur.pps,
&w.sh,
&mut cur.pic,
&dpb,
&w.refs,
&mut cur.carry,
w.slice_idx,
w.slice_addr,
);
dec.decode(&w.rbsp)?;
}
filters::deblock(&mut cur.pic, &cur.sps, &cur.pps);
if cur.sps.sao {
filters::sao(&mut cur.pic, &cur.sps, &cur.pps);
}
let frame = cur.output.then(|| {
let (fmt, crop, color) = output_format(&cur.sps);
DecodedFrame::from_planes(&cur.pic.planes, fmt, cur.sps.bit_depth_y as u8, crop, color)
});
let layout = cur.pic.layout.clone();
Ok((ref_data(cur.pic, &layout), frame))
}