use crate::internal::{DecoderContext, ThreadPicture};
use std::sync::atomic::Ordering::Relaxed;
pub(crate) fn disp_order_hint(
c: &DecoderContext,
order_hint: u32,
order_hint_bits: u32,
closed_loop_key: bool,
) -> i64 {
if closed_loop_key {
return order_hint as i64;
}
let max = c
.refs
.iter()
.filter(|r| r.p.pic.is_some())
.filter(|r| {
r.p.frame_hdr
.as_ref()
.is_some_and(|h| h.show_immediate != 0 || h.show_implicit != 0)
})
.map(|r| r.p.disp_order)
.max()
.unwrap_or(0)
.max(0);
let factor = 1i64 << order_hint_bits;
let mut cur = order_hint as i64;
while (max - cur).abs() >= factor >> 1 {
if cur > max {
return cur;
}
cur += factor;
}
cur
}
fn eligible(p: &ThreadPicture) -> bool {
p.pic.is_some()
&& p.frame_hdr.as_ref().is_some_and(|h| h.show_implicit != 0)
&& p.out_done.as_ref().is_some_and(|d| !d.load(Relaxed))
}
fn emit(c: &mut DecoderContext, p: &ThreadPicture) {
let Some(pic) = p.pic.as_ref() else {
return;
};
if let Some(d) = p.out_done.as_ref() {
d.store(true, Relaxed);
}
c.frame_out.push(pic.shallow_clone());
}
fn earliest(c: &DecoderContext, pred: impl Fn(i64) -> bool) -> Option<usize> {
(0..c.refs.len())
.filter(|&i| eligible(&c.refs[i].p) && pred(c.refs[i].p.disp_order))
.min_by_key(|&i| c.refs[i].p.disp_order)
}
pub(crate) fn output_frame_buffers(c: &mut DecoderContext, trigger: &ThreadPicture) {
while let Some(i) = earliest(c, |d| d < trigger.disp_order) {
let p = c.refs[i].p.clone();
emit(c, &p);
}
emit(c, trigger);
let mut next = trigger.disp_order + 1;
while let Some(i) = earliest(c, |d| d == next) {
let p = c.refs[i].p.clone();
emit(c, &p);
next += 1;
}
}
pub(crate) fn output_before_overwrite(c: &mut DecoderContext, slot: usize) {
if eligible(&c.refs[slot].p) {
let p = c.refs[slot].p.clone();
output_frame_buffers(c, &p);
}
}
pub(crate) fn flush_remaining(c: &mut DecoderContext) {
while let Some(i) = earliest(c, |_| true) {
let p = c.refs[i].p.clone();
emit(c, &p);
}
}