1use 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
29pub 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
40pub 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}