use std::sync::Arc;
use md5::{Digest, Md5};
use unityrs_core::files::SerializedFile;
use unityrs_core::limits::{Charge, ChargeError, Meter, MeteredVec, heap_cost};
use unityrs_core::{Parsed, Value};
use unityrs_imageio::{Buffer, Charger, EncodeError, ImageError, visible_hash};
use unityrs_texture::{Format, Image, Mode, decode_in_as, plan_in_as};
use super::attempt::{Attempt, Site};
use super::classify::{self, Class, Reason};
use super::plan::{AtlasPlan, Planned, SpritePlan, TexturePlan, png_mode, too_wide};
use super::read::{Texture, field};
use super::seam::Seam;
use super::table;
use super::{
Failure, ImageEncoding, MemberPath, Output, OutputKind, Picture, SkipOutput, resource,
};
use crate::pyjson::{self, Count, Sink, WriteError};
struct Metered<'m>(&'m Arc<Meter>);
impl Charger for Metered<'_> {
type Charge = Charge;
type Refusal = ChargeError;
fn charge(&mut self, _: Buffer, requests: &[usize]) -> Result<Charge, ChargeError> {
let bytes = requests.iter().fold(0u64, |sum, r| {
sum.saturating_add(heap_cost(u64::try_from(*r).unwrap_or(u64::MAX)))
});
self.0.charge(bytes)
}
}
pub(super) fn md5(bytes: &[u8]) -> [u8; 16] {
let digest = Md5::digest(bytes);
let mut out = [0u8; 16];
out.copy_from_slice(&digest);
out
}
pub(super) type File = (Vec<u8>, Charge, Option<Picture>);
pub(super) fn decoded(
seam: &Seam<'_>,
file: &Arc<SerializedFile>,
t: &Texture,
format: Format,
plain: bool,
) -> Result<Image, Class> {
let _sample = super::read::Sample(file.meter(), seam.hooks);
let data = resource::data(seam, file, t)?;
let format = super::read::data_format(t, file, format, &data)?;
let mut blob = [0u8; 12];
let fields = t.fields(
format.texture_format(),
file.target_platform().unwrap_or(0),
&mut blob,
);
let planned =
seam.probe(|| plan_in_as(format, &fields, data.len()).map_err(|e| classify::decode(&e)))?;
if plain && too_wide(planned.width, planned.mode) {
return Err(unwritable());
}
seam.work(planned.output_bytes)?;
seam.probe(|| {
#[cfg(feature = "test-hooks")]
let result = unityrs_texture::contain(std::panic::AssertUnwindSafe(|| {
seam.hooks.decoder_fault();
decode_in_as(format, &fields, &data, seam.meter)
}));
#[cfg(not(feature = "test-hooks"))]
let result = decode_in_as(format, &fields, &data, seam.meter);
result.map_err(|e| classify::decode(&e))
})
}
pub(super) struct Pixels<'p> {
pub mode: Mode,
pub width: u32,
pub height: u32,
pub data: &'p [u8],
}
fn encoded(e: EncodeError<ChargeError>) -> Class {
match e {
EncodeError::Image(ImageError::TooWide { .. }) => {
Class::Skip(Reason::decode_error("pillow_memory_error"))
}
EncodeError::Refused { refusal, .. } => classify::charge(&refusal),
EncodeError::Alloc { .. } | EncodeError::ZlibMemory => table::host_memory(),
_ => Class::Run(Reason::plain("internal")),
}
}
pub(super) fn png(
p: &Pixels<'_>,
meter: &Arc<Meter>,
encoding: ImageEncoding,
) -> Result<(Vec<u8>, Charge, Picture), Class> {
let image = unityrs_imageio::Image::new(p.width, p.height, png_mode(p.mode), p.data)
.map_err(|e| encoded(EncodeError::Image(e)))?;
let (bytes, charge) = match encoding {
ImageEncoding::Png => unityrs_imageio::encode(&image, &mut Metered(meter))
.map_err(encoded)?
.into_parts(),
ImageEncoding::PngFast => unityrs_imageio::encode_fast(&image, &mut Metered(meter))
.map_err(encoded)?
.into_parts(),
ImageEncoding::Webp { quality } => unityrs_imageio::encode_webp(
&image,
unityrs_imageio::WebpOptions {
quality: f32::from(quality),
..Default::default()
},
&mut Metered(meter),
)
.map_err(|e| match e {
unityrs_imageio::WebpError::Refused { refusal, .. } => classify::charge(&refusal),
unityrs_imageio::WebpError::Memory => table::host_memory(),
unityrs_imageio::WebpError::Dimensions { .. } => {
Class::Skip(Reason::decode_error("pillow_value_error"))
}
_ => Class::Run(Reason::plain("internal")),
})?
.into_parts(),
};
let picture = Picture {
mode: png_mode(p.mode).name(),
width: p.width,
height: p.height,
visible_hash: visible_hash(&image),
};
Ok((bytes, charge, picture))
}
fn crop(sheet: &Image, sprite: &SpritePlan, seam: &Seam<'_>) -> Result<(Vec<u8>, Charge), Class> {
let bpp: u64 = match sheet.mode() {
Mode::L => 1,
Mode::Rgb => 3,
Mode::Rgba => 4,
};
let row = sprite.width.saturating_mul(bpp);
let size = row.saturating_mul(sprite.height);
seam.work(size)?;
let charge = seam.probe(|| {
seam.meter
.charge(heap_cost(size))
.map_err(|e| classify::charge(&e))
})?;
let n = usize::try_from(size).map_err(|_| table::host_memory())?;
let mut out = Vec::new();
out.try_reserve_exact(n).map_err(|_| table::host_memory())?;
out.resize(n, 0);
let (sw, sh) = (i128::from(sheet.width()), i128::from(sheet.height()));
let (w, h) = (i128::from(sprite.width), i128::from(sprite.height));
let x0 = sprite.x.max(0);
let x1 = (sprite.x + w).min(sw);
let bpp = i128::from(bpp);
let src_row = sw * bpp;
let dst_row = w * bpp;
if x0 < x1 {
for r in 0..h {
let y = sprite.y + r;
if y < 0 || y >= sh {
continue;
}
let src = usize::try_from(y * src_row + x0 * bpp).unwrap_or(usize::MAX);
let dst = usize::try_from(r * dst_row + (x0 - sprite.x) * bpp).unwrap_or(usize::MAX);
let len = usize::try_from((x1 - x0) * bpp).unwrap_or(0);
let from = sheet.pixels().get(src..src.saturating_add(len));
let to = out.get_mut(dst..dst.saturating_add(len));
if let (Some(from), Some(to)) = (from, to) {
to.copy_from_slice(from);
}
}
}
Ok((out, charge))
}
fn key(out: &mut impl Sink, k: &str) {
out.put(b",\n \"");
out.put(k.as_bytes());
out.put(b"\": ");
}
fn value_or_null(
parsed: &Parsed,
v: Option<&Value>,
out: &mut impl Sink,
meter: &Arc<Meter>,
) -> Result<(), WriteError> {
if let Some(v) = v {
return pyjson::value(parsed, v, 1, out, meter);
}
out.put(b"null");
Ok(())
}
fn atlas_json(
atlas: &AtlasPlan,
width: u32,
height: u32,
out: &mut impl Sink,
meter: &Arc<Meter>,
) -> Result<(), WriteError> {
let parsed = &atlas.parsed;
let root = parsed.value();
let get = |name: &[u8]| field(parsed, root, name);
let sprites = get(b"mSprites");
let count = match sprites {
Some(Value::List(v)) => v.len(),
Some(Value::Prims(p)) => p.len(),
_ => 0,
};
out.put(b"{\n \"name\": ");
pyjson::string(atlas.name.as_bytes(), out);
key(out, "texture_width");
pyjson::int(width.into(), out);
key(out, "texture_height");
pyjson::int(height.into(), out);
key(out, "pixel_size");
value_or_null(parsed, get(b"mPixelSize"), out, meter)?;
key(out, "settings");
value_or_null(parsed, get(b"mSettings"), out, meter)?;
key(out, "sprite_count");
pyjson::int(i128::try_from(count).unwrap_or(i128::MAX), out);
key(out, "sprites");
value_or_null(parsed, sprites, out, meter)?;
out.put(b"\n}");
Ok(())
}
pub(super) struct Made<'p> {
pub plan_index: u64,
pub kind: OutputKind,
pub key: &'p str,
pub unit: Option<&'p str>,
pub members: &'p [MemberPath],
}
fn unwritable() -> Class {
Class::Skip(Reason::decode_error("pillow_memory_error"))
}
fn paths_cost(members: &[MemberPath]) -> u64 {
members.iter().fold(0, |sum: u64, m| {
let len = match &m.path {
Ok(p) => p.len(),
Err(r) => r.path.len(),
};
sum.saturating_add(table::string(len))
})
}
impl Attempt<'_> {
pub(super) fn output(
&mut self,
made: &Made<'_>,
site: &Site<'_>,
file: (Vec<u8>, Charge, Option<Picture>),
) -> Result<bool, Failure> {
let (bytes, mut charge, picture) = file;
let copy = match made.members.len() {
0 => 0,
n => heap_cost(table::slots::<MemberPath>(n)),
};
let cost = table::string(made.key.len())
.saturating_add(made.unit.map_or(0, |u| table::string(u.len())))
.saturating_add(copy)
.saturating_add(paths_cost(made.members));
let grown = self
.seam
.probe(|| charge.grow(cost).map_err(|e| table::refused(&e)));
if let Err(c) = grown {
self.record(c, site)?;
return Ok(false);
}
let output = Output {
prefab: None,
plan_index: made.plan_index,
key: made.key.to_owned(),
kind: made.kind,
unit: made.unit.map(str::to_owned),
serialized_file: site.obj.file().name().clone(),
path_id: site.obj.path_id(),
sprite: site.sprite,
md5: md5(&bytes),
bytes,
picture,
members: made.members.to_vec(),
_charge: Some(charge),
};
self.emit(output)?;
Ok(true)
}
fn image(&mut self, i: usize, plain: bool) -> Result<Image, Class> {
let internal = || Class::Run(Reason::plain("internal"));
let t = self.texture(i)?;
let Ok(format) = self.selection(i, &t) else {
return Err(internal());
};
let Some(file) = self.texs.as_slice().get(i).map(|x| x.obj.file().clone()) else {
return Err(internal());
};
decoded(&self.seam, &file, &t, format, plain)
}
pub fn export(&mut self, planned: &Planned) -> Result<(), Failure> {
self.exporting = true;
self.export_sprites(&planned.sprites)?;
let meter = self.seam.meter;
let atlases = planned.atlases.as_slice();
let textures = planned.textures.as_slice();
let sheet = |j: u32| {
atlases
.get(usize::try_from(j).unwrap_or(usize::MAX))
.map_or(usize::MAX, |a| a.sheet)
};
let internal = || Failure::Run(Reason::plain("internal"));
let mut order: MeteredVec<u32> =
self.charged(|| table::with_capacity(meter, atlases.len()))?;
for j in 0..atlases.len() {
let j = u32::try_from(j).map_err(|_| internal())?;
self.charged(|| table::push(&mut order, j))?;
}
order
.as_mut_slice()
.sort_unstable_by(|a, b| sheet(*a).cmp(&sheet(*b)).then(a.cmp(b)));
let mut runs: MeteredVec<(u32, usize, usize)> = MeteredVec::new(meter);
let sorted = order.as_slice();
let mut start = 0;
while let Some(&first) = sorted.get(start) {
let s = sheet(first);
let len = sorted
.get(start..)
.unwrap_or_default()
.iter()
.take_while(|j| sheet(**j) == s)
.count();
self.charged(|| table::push(&mut runs, (first, start, start + len)))?;
start += len;
}
runs.as_mut_slice().sort_unstable_by_key(|r| r.0);
let texture = |tex: usize| {
textures
.binary_search_by_key(&tex, |t| t.tex)
.ok()
.and_then(|i| textures.get(i))
};
for &(first, from, to) in runs.as_slice() {
self.seam.stop()?;
let group = sorted.get(from..to).unwrap_or_default();
let s = sheet(first);
self.export_sheet(s, texture(s), group, atlases)?;
}
for tp in textures {
let is_sheet = {
let at = sorted.partition_point(|j| sheet(*j) < tp.tex);
sorted.get(at).is_some_and(|j| sheet(*j) == tp.tex)
};
if is_sheet {
continue;
}
self.seam.stop()?;
let Some(obj) = self.texs.as_slice().get(tp.tex).map(|t| t.obj.clone()) else {
continue;
};
let site = Site {
obj: &obj,
output: SkipOutput::Texture,
sprite: None,
};
let made = Made {
plan_index: tp.plan_index,
kind: OutputKind::Texture,
key: &tp.key,
unit: None,
members: tp.members.as_slice(),
};
match self
.image(tp.tex, true)
.and_then(|img| self.texture_png(&img))
{
Ok(file) => {
self.output(&made, &site, file)?;
}
Err(c) => self.record(c, &site)?,
}
}
Ok(())
}
fn texture_png(&self, img: &Image) -> Result<File, Class> {
let p = Pixels {
mode: img.mode(),
width: img.width(),
height: img.height(),
data: img.pixels(),
};
let meter = self.seam.meter;
self.seam
.probe(|| png(&p, meter, self.options.image).map(|(b, c, pic)| (b, c, Some(pic))))
}
fn export_sheet(
&mut self,
sheet: usize,
texture: Option<&TexturePlan>,
group: &[u32],
atlases: &[AtlasPlan],
) -> Result<(), Failure> {
let Some(obj) = self.texs.as_slice().get(sheet).map(|t| t.obj.clone()) else {
return Ok(());
};
let tex_site = Site {
obj: &obj,
output: SkipOutput::Texture,
sprite: None,
};
let atlas = |j: &u32| atlases.get(usize::try_from(*j).unwrap_or(usize::MAX));
let img = match self.image(sheet, false) {
Ok(img) => img,
Err(Class::Skip(r)) => {
if texture.is_some() {
self.skip(&tex_site, r.clone())?;
}
for a in group.iter().filter_map(atlas).filter(|a| a.has_outputs()) {
let site = Site {
obj: &a.obj,
output: SkipOutput::Atlas,
sprite: None,
};
self.skip(&site, r.clone())?;
}
return Ok(());
}
Err(c) => return Err(c.into()),
};
let mut unit = None;
if let Some(tp) = texture {
self.seam.stop()?;
let file = if too_wide(img.width(), img.mode()) {
Err(unwritable())
} else {
self.texture_png(&img)
};
match file {
Ok(file) => {
let made = Made {
plan_index: tp.plan_index,
kind: OutputKind::Texture,
key: &tp.key,
unit: Some(&tp.key),
members: tp.members.as_slice(),
};
if self.output(&made, &tex_site, file)? {
unit = Some(tp.key.as_str());
}
}
Err(c) => self.record(c, &tex_site)?,
}
}
for a in group.iter().filter_map(atlas) {
self.export_atlas(a, &img, unit)?;
}
Ok(())
}
fn export_atlas(
&mut self,
a: &AtlasPlan,
img: &Image,
unit: Option<&str>,
) -> Result<(), Failure> {
let mut unit = unit;
if let Some(key) = &a.json_key {
self.seam.stop()?;
let site = Site {
obj: &a.obj,
output: SkipOutput::AtlasJson,
sprite: None,
};
match self.json(a, img) {
Ok(Some(file)) => {
let u = unit.unwrap_or(key);
let made = Made {
plan_index: a.json_plan_index,
kind: OutputKind::AtlasJson,
key,
unit: Some(u),
members: a.json_members.as_slice(),
};
if self.output(&made, &site, file)? {
unit = Some(u);
}
}
Ok(None) => self.skip(&site, Reason::plain("json_unwritable"))?,
Err(c) => self.record(c, &site)?,
}
}
for s in a.sprites.as_slice() {
self.seam.stop()?;
let site = Site {
obj: &a.obj,
output: SkipOutput::AtlasSprite,
sprite: Some(s.index),
};
let seam = self.seam;
let made = crop(img, s, &seam).and_then(|(pixels, _held)| {
let p = Pixels {
mode: img.mode(),
width: u32::try_from(s.width).unwrap_or(u32::MAX),
height: u32::try_from(s.height).unwrap_or(u32::MAX),
data: &pixels,
};
seam.probe(|| png(&p, seam.meter, self.options.image))
});
match made {
Ok((bytes, charge, pic)) => {
let made = Made {
plan_index: s.plan_index,
kind: OutputKind::AtlasSprite,
key: &s.key,
unit,
members: s.members.as_slice(),
};
self.output(&made, &site, (bytes, charge, Some(pic)))?;
}
Err(c) => self.record(c, &site)?,
}
}
Ok(())
}
fn json(&self, a: &AtlasPlan, img: &Image) -> Result<Option<File>, Class> {
let seam = self.seam;
let meter = seam.meter;
let written = |r: Result<(), WriteError>| match r {
Ok(()) => Ok(true),
Err(WriteError::Unwritable(_)) => Ok(false),
Err(WriteError::Charge(e)) => Err(table::refused(&e)),
};
let mut count = Count::default();
if !seam.probe(|| written(atlas_json(a, img.width(), img.height(), &mut count, meter)))? {
return Ok(None);
}
let charge = seam.probe(|| {
meter
.charge(heap_cost(count.0))
.map_err(|e| table::refused(&e))
})?;
let n = usize::try_from(count.0).map_err(|_| table::host_memory())?;
let mut out = Vec::new();
out.try_reserve_exact(n).map_err(|_| table::host_memory())?;
if !seam.probe(|| written(atlas_json(a, img.width(), img.height(), &mut out, meter)))? {
return Ok(None);
}
Ok(Some((out, charge, None)))
}
}