Skip to main content

unityrs_export/
audio.rs

1// Ported from UnityPy 1.25.2 (MIT): export/AudioClipConverter.py's AudioClip data selection. See THIRD_PARTY_LICENSES.
2//! A multi-file `AudioClip` exporter; no batch kind is added. Inline bytes win
3//! over streamed data (export/AudioClipConverter.py:20-33). Old layouts hold
4//! `m_AudioData` and `m_Type`; 5.x layouts hold `m_Resource` and
5//! `m_CompressionFormat` (classes/generated.py:4180-4201). The pinned converter
6//! does not consult either format field during sample dispatch.
7//!
8//! An empty resource returns no files before resolving its path (Tier B,
9//! PARITY.md section 19.2); otherwise source errors retain their provenance.
10use crate::simple;
11use std::sync::Arc;
12use unityrs_audio::{Sample, VorbisHeaders};
13use unityrs_core::{
14    ObjectRef, PrimArray, Value,
15    env::Environment,
16    limits::{Meter, MeteredVec},
17};
18
19#[derive(Debug, thiserror::Error)]
20pub enum Error {
21    #[error(transparent)]
22    Read(#[from] simple::Error),
23    #[error(transparent)]
24    Audio(#[from] unityrs_audio::Error),
25}
26const _: () = send_sync::<Error>();
27const fn send_sync<T: Send + Sync + ?Sized>() {}
28
29/// Export class 83 through its typetree and the Environment's resource
30/// resolver. Output names and WAVs retain their charges on `meter`.
31pub fn export(
32    obj: &ObjectRef,
33    env: &Environment,
34    convert_float: bool,
35    meter: &Arc<Meter>,
36) -> Result<MeteredVec<Sample>, Error> {
37    export_with_vorbis(obj, env, convert_float, None, meter)
38}
39
40/// Export using runtime Vorbis setup headers supplied by the caller. Enable
41/// the `vorbis` feature for the decoder; batch never calls this exporter.
42pub fn export_with_vorbis(
43    obj: &ObjectRef,
44    env: &Environment,
45    convert_float: bool,
46    headers: Option<&VorbisHeaders>,
47    meter: &Arc<Meter>,
48) -> Result<MeteredVec<Sample>, Error> {
49    if obj.class_id() != 83 {
50        return Err(simple::Error::UnsupportedClass(obj.class_id()).into());
51    }
52    let parsed = simple::read(obj, env)?;
53    let name = simple::attr(&parsed, b"m_Name")?;
54    let Value::Str(name) = name else {
55        return Err(simple::Error::Field("m_Name").into());
56    };
57    let dict = parsed
58        .value()
59        .as_dict()
60        .ok_or(simple::Error::Field("AudioClip"))?;
61    let inline = parsed
62        .attr(dict, b"m_AudioData")
63        .map(|v| inline(v, meter))
64        .transpose()?;
65    if let Some(data) = inline.as_ref().filter(|d| !d.bytes().is_empty()) {
66        let plan = unityrs_audio::plan(data.bytes(), convert_float, meter)?;
67        return Ok(unityrs_audio::decode_with_vorbis(
68            &plan,
69            name.as_bytes(),
70            headers,
71            meter,
72        )?);
73    }
74    let resource = parsed
75        .attr(dict, b"m_Resource")
76        .and_then(Value::as_dict)
77        .ok_or(simple::Error::Field("m_AudioData or m_Resource"))?;
78    let get = |key| {
79        parsed
80            .attr(resource, key)
81            .ok_or(simple::Error::Field("m_Resource"))
82    };
83    let size = get(b"m_Size")?
84        .as_u64()
85        .ok_or(simple::Error::Field("m_Size"))?;
86    if size == 0 {
87        return Ok(MeteredVec::new(meter));
88    }
89    let Value::Str(path) = get(b"m_Source")? else {
90        return Err(simple::Error::Field("m_Source").into());
91    };
92    let offset = get(b"m_Offset")?
93        .as_u64()
94        .ok_or(simple::Error::Field("m_Offset"))?;
95    let data = env
96        .resource(obj.file(), path, offset, size)
97        .map_err(simple::Error::from)?;
98    let plan = unityrs_audio::plan(&data, convert_float, meter)?;
99    Ok(unityrs_audio::decode_with_vorbis(
100        &plan,
101        name.as_bytes(),
102        headers,
103        meter,
104    )?)
105}
106enum Inline<'a> {
107    Borrowed(&'a [u8]),
108    Copied(MeteredVec<u8>),
109}
110impl Inline<'_> {
111    fn bytes(&self) -> &[u8] {
112        match self {
113            Self::Borrowed(b) => b,
114            Self::Copied(b) => b.as_slice(),
115        }
116    }
117}
118fn inline<'a>(value: &'a Value, meter: &Arc<Meter>) -> Result<Inline<'a>, simple::Error> {
119    macro_rules! ints {
120        ($values:expr) => {
121            copy($values.iter().map(|&n| u8::try_from(n).ok()), meter)
122        };
123    }
124    match value {
125        Value::Bytes(b) | Value::Prims(PrimArray::U8(b)) => Ok(Inline::Borrowed(b)),
126        Value::List(v) => values(v, meter),
127        Value::Tuple(v) => values(v, meter),
128        Value::Prims(p) => match p {
129            PrimArray::Bool(v) => copy(v.iter().map(|&n| Some(u8::from(n))), meter),
130            PrimArray::I8(v) => ints!(v),
131            PrimArray::U16(v) => ints!(v),
132            PrimArray::I16(v) => ints!(v),
133            PrimArray::U32(v) => ints!(v),
134            PrimArray::I32(v) => ints!(v),
135            PrimArray::U64(v) => ints!(v),
136            PrimArray::I64(v) => ints!(v),
137            _ => Err(simple::Error::Field("m_AudioData byte")),
138        },
139        _ => Err(simple::Error::Field("m_AudioData")),
140    }
141}
142fn copy<'a>(
143    bytes: impl ExactSizeIterator<Item = Option<u8>>,
144    meter: &Arc<Meter>,
145) -> Result<Inline<'a>, simple::Error> {
146    meter.count_decode(bytes.len() as u64)?;
147    let mut out = MeteredVec::with_capacity(meter, bytes.len())?;
148    for b in bytes {
149        out.push(b.ok_or(simple::Error::Field("m_AudioData byte"))?)?;
150    }
151    Ok(Inline::Copied(out))
152}
153
154fn values<'a>(v: &[Value], meter: &Arc<Meter>) -> Result<Inline<'a>, simple::Error> {
155    copy(
156        v.iter().map(|v| {
157            v.as_u64()
158                .and_then(|n| u8::try_from(n).ok())
159                .or_else(|| v.as_bool().map(u8::from))
160        }),
161        meter,
162    )
163}