use alloc::vec::Vec;
use crate::color::{self, Source};
use crate::context::Context;
use crate::error::{Error, Result};
use crate::grid::{self, Grid, Mosaic};
use crate::hevc::{self, Frame, VideoSignal};
use crate::image::{DecodeOptions, Image, check_pixels};
use crate::parallel;
use crate::props::ItemProps;
use crate::props::colr::Nclx;
use crate::transform;
pub fn decode(bytes: &[u8], options: &DecodeOptions) -> Result<Image> {
parallel::scope(options.threads, |threads| {
run(bytes, None, options, threads)
})
}
pub fn decode_image(bytes: &[u8], id: u32, options: &DecodeOptions) -> Result<Image> {
parallel::scope(options.threads, |threads| {
run(bytes, Some(id), options, threads)
})
}
fn run(
bytes: &[u8],
id: Option<u32>,
options: &DecodeOptions,
threads: Option<usize>,
) -> Result<Image> {
let ctx = Context::open(bytes)?;
let id = match id {
Some(id) => ctx.image(id)?,
None => ctx.meta.primary,
};
let p = ctx.props(id)?;
if options.strict && ctx.meta.props.unknown_essential(id).is_some() {
return Err(Error::Unsupported(
"the item carries an essential property this build does not implement",
));
}
let limit = options.pixel_limit();
let (cw, ch) = ctx.coded_size(id, &p)?;
check_pixels(cw, ch, limit)?;
let (tw, th) = transform::transformed_size(cw, ch, &p.transforms)?;
check_pixels(tw, th, limit)?;
let decoded = decode_item(&ctx, id, &p, threads)?;
let alpha = alpha_frame(&ctx, id, options, limit, threads)?;
let nclx = match ctx.declared_nclx(id)? {
Some(declared) => declared,
None => resolve_nclx(&ctx, id, &p)?,
};
let (layout, alpha) = (options.layout, alpha.as_ref());
let image = match &decoded {
Decoded::Picture(frame) => {
color::convert_source(&Source::Frame(frame), alpha, nclx, layout, limit, threads)?
}
Decoded::Tiles(g, tiles) => {
let mosaic = Mosaic::new(g, tiles)?;
color::convert_source(
&Source::Mosaic(&mosaic),
alpha,
nclx,
layout,
limit,
threads,
)?
}
};
if options.apply_transforms {
transform::apply_all(image, &p.transforms)
} else {
Ok(image)
}
}
enum Decoded {
Picture(Frame),
Tiles(Grid, Vec<Frame>),
}
impl Decoded {
fn into_frame(self, limit: u64) -> Result<Frame> {
match self {
Decoded::Picture(frame) => Ok(frame),
Decoded::Tiles(g, tiles) => grid::compose(&g, &tiles, limit),
}
}
}
fn decode_item(
ctx: &Context<'_>,
id: u32,
p: &ItemProps<'_>,
threads: Option<usize>,
) -> Result<Decoded> {
match ctx.grid(id)? {
Some((g, tiles)) => {
let frames =
parallel::try_map(&tiles, threads, |t| decode_coded(ctx, *t, &ctx.props(*t)?))?;
Ok(Decoded::Tiles(g, frames))
}
None => decode_coded(ctx, id, p).map(Decoded::Picture),
}
}
fn decode_coded(ctx: &Context<'_>, id: u32, p: &ItemProps<'_>) -> Result<Frame> {
let hvcc = p.hvcc.as_ref().ok_or(Error::MissingBox("hvcC"))?;
let data = ctx.item_data(id)?;
let nals = hvcc.split_nals(&data)?;
let params = hvcc.parameter_sets();
if params.is_empty() {
return Err(Error::Malformed("hvcC carries no parameter sets"));
}
let frame = hevc::decode_still(¶ms, &nals)?;
frame.validate()?;
Ok(frame)
}
fn alpha_frame(
ctx: &Context<'_>,
id: u32,
options: &DecodeOptions,
limit: u64,
threads: Option<usize>,
) -> Result<Option<Frame>> {
if !options.decode_alpha || !options.layout.has_alpha() {
return Ok(None);
}
let Some(aux) = ctx.alpha_item(id)? else {
return Ok(None);
};
let aux_props = ctx.props(aux)?;
decode_item(ctx, aux, &aux_props, threads)?
.into_frame(limit)
.map(Some)
}
pub fn effective_nclx(p: &ItemProps<'_>) -> Nclx {
p.nclx.unwrap_or_default()
}
pub fn pick_nclx(own: Option<Nclx>, coded: Option<VideoSignal>) -> Nclx {
own.or_else(|| coded.map(Nclx::from)).unwrap_or_default()
}
fn resolve_nclx(ctx: &Context<'_>, id: u32, p: &ItemProps<'_>) -> Result<Nclx> {
if p.nclx.is_some() {
return Ok(pick_nclx(p.nclx, None));
}
let coded = match ctx.grid(id)? {
Some((_, tiles)) => match tiles.first() {
Some(tile) => coded_signal(&ctx.props(*tile)?)?,
None => None,
},
None => coded_signal(p)?,
};
Ok(pick_nclx(None, coded))
}
fn coded_signal(p: &ItemProps<'_>) -> Result<Option<VideoSignal>> {
let Some(hvcc) = p.hvcc.as_ref() else {
return Ok(None);
};
hevc::video_signal(&hvcc.parameter_sets())
}