1 pub use crate::formats::{NASoniton,NAChannelMap};
2 pub use crate::frame::{NAAudioBuffer,NAAudioInfo,NABufferType};
3 use crate::formats::NAChannelType;
4 use crate::frame::alloc_audio_buffer;
5 use crate::io::byteio::*;
6 use std::f32::consts::SQRT_2;
8 #[derive(Clone,Copy,Debug,PartialEq)]
9 pub enum SoundConvertError {
23 fn is_remix(&self) -> bool {
25 ChannelOp::Remix(_) => true,
26 ChannelOp::DupMono(_) => true,
32 fn apply_channel_op<T:Copy>(ch_op: &ChannelOp, src: &Vec<T>, dst: &mut Vec<T>) {
34 ChannelOp::Passthrough => {
35 dst.copy_from_slice(src.as_slice());
37 ChannelOp::Reorder(ref reorder) => {
38 for (out, idx) in dst.iter_mut().zip(reorder.iter()) {
46 fn remix_i32(ch_op: &ChannelOp, src: &Vec<i32>, dst: &mut Vec<i32>) {
47 if let ChannelOp::Remix(ref remix_mat) = ch_op {
49 for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) {
51 for (inval, coef) in src.iter().zip(coeffs.iter()) {
52 sum += (*inval as f32) * *coef;
57 if let ChannelOp::DupMono(ref dup_mat) = ch_op {
59 for (out, copy) in dst.iter_mut().zip(dup_mat.iter()) {
60 *out = if *copy { src } else { 0 };
65 fn remix_f32(ch_op: &ChannelOp, src: &Vec<f32>, dst: &mut Vec<f32>) {
66 if let ChannelOp::Remix(ref remix_mat) = ch_op {
68 for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) {
70 for (inval, coef) in src.iter().zip(coeffs.iter()) {
71 sum += *inval * *coef;
76 if let ChannelOp::DupMono(ref dup_mat) = ch_op {
78 for (out, copy) in dst.iter_mut().zip(dup_mat.iter()) {
79 *out = if *copy { src } else { 0.0 };
84 fn read_samples<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<T>) {
85 let stride = src.get_stride();
86 let data = src.get_data();
87 for out in dst.iter_mut() {
93 trait FromFmt<T:Copy> {
94 fn cvt_from(val: T) -> Self;
97 impl FromFmt<u8> for u8 {
98 fn cvt_from(val: u8) -> u8 { val }
100 impl FromFmt<u8> for i16 {
101 fn cvt_from(val: u8) -> i16 { ((val as i16) - 128).wrapping_mul(0x101) }
103 impl FromFmt<u8> for i32 {
104 fn cvt_from(val: u8) -> i32 { ((val as i32) - 128).wrapping_mul(0x01010101) }
106 impl FromFmt<u8> for f32 {
107 fn cvt_from(val: u8) -> f32 { ((val as f32) - 128.0) / 128.0 }
110 impl FromFmt<i16> for u8 {
111 fn cvt_from(val: i16) -> u8 { ((val >> 8) + 128).min(255).max(0) as u8 }
113 impl FromFmt<i16> for i16 {
114 fn cvt_from(val: i16) -> i16 { val }
116 impl FromFmt<i16> for i32 {
117 fn cvt_from(val: i16) -> i32 { (val as i32).wrapping_mul(0x10001) }
119 impl FromFmt<i16> for f32 {
120 fn cvt_from(val: i16) -> f32 { (val as f32) / 32768.0 }
123 impl FromFmt<i32> for u8 {
124 fn cvt_from(val: i32) -> u8 { ((val >> 24) + 128).min(255).max(0) as u8 }
126 impl FromFmt<i32> for i16 {
127 fn cvt_from(val: i32) -> i16 { (val >> 16) as i16 }
129 impl FromFmt<i32> for i32 {
130 fn cvt_from(val: i32) -> i32 { val }
132 impl FromFmt<i32> for f32 {
133 fn cvt_from(val: i32) -> f32 { (val as f32) / 31.0f32.exp2() }
136 impl FromFmt<f32> for u8 {
137 fn cvt_from(val: f32) -> u8 { ((val * 128.0) + 128.0).min(255.0).max(0.0) as u8 }
139 impl FromFmt<f32> for i16 {
140 fn cvt_from(val: f32) -> i16 { (val * 32768.0).min(16383.0).max(-16384.0) as i16 }
142 impl FromFmt<f32> for i32 {
143 fn cvt_from(val: f32) -> i32 { (val * 31.0f32.exp2()) as i32 }
145 impl FromFmt<f32> for f32 {
146 fn cvt_from(val: f32) -> f32 { val }
149 trait IntoFmt<T:Copy> {
150 fn cvt_into(self) -> T;
153 impl<T:Copy, U:Copy> IntoFmt<U> for T where U: FromFmt<T> {
154 fn cvt_into(self) -> U { U::cvt_from(self) }
158 fn read_samples_i32<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<i32>) where i32: FromFmt<T> {
159 let stride = src.get_stride();
160 let data = src.get_data();
161 for out in dst.iter_mut() {
162 *out = i32::cvt_from(data[idx]);
167 fn read_samples_f32<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<f32>) where f32: FromFmt<T> {
168 let stride = src.get_stride();
169 let data = src.get_data();
170 for out in dst.iter_mut() {
171 *out = f32::cvt_from(data[idx]);
176 fn read_packed<T:Copy>(src: &NAAudioBuffer<u8>, idx: usize, dst: &mut Vec<T>, fmt: &NASoniton) where u8: IntoFmt<T>, i16: IntoFmt<T>, i32: IntoFmt<T>, f32: IntoFmt<T> {
177 if (fmt.bits & 7) != 0 { unimplemented!(); }
178 let bytes = (fmt.bits >> 3) as usize;
179 let mut offset = idx * bytes * dst.len();
180 let data = src.get_data();
182 for el in dst.iter_mut() {
183 let src = &data[offset..];
184 *el = if !fmt.float {
185 match (bytes, fmt.be) {
186 (1, _) => src[0].cvt_into(),
187 (2, true) => (read_u16be(src).unwrap() as i16).cvt_into(),
188 (2, false) => (read_u16le(src).unwrap() as i16).cvt_into(),
189 (3, true) => ((read_u24be(src).unwrap() << 8) as i32).cvt_into(),
190 (3, false) => ((read_u24be(src).unwrap() << 8) as i32).cvt_into(),
191 (4, true) => (read_u32be(src).unwrap() as i32).cvt_into(),
192 (4, false) => (read_u32be(src).unwrap() as i32).cvt_into(),
196 match (bytes, fmt.be) {
197 (4, true) => read_f32be(src).unwrap().cvt_into(),
198 (4, false) => read_f32le(src).unwrap().cvt_into(),
199 (8, true) => (read_f64be(src).unwrap() as f32).cvt_into(),
200 (8, false) => (read_f64le(src).unwrap() as f32).cvt_into(),
201 (_, _) => unreachable!(),
208 fn store_samples<T:Copy, U:Copy>(dst: &mut NAAudioBuffer<T>, mut idx: usize, src: &Vec<U>) where U: IntoFmt<T> {
209 let stride = dst.get_stride();
210 let data = dst.get_data_mut().unwrap();
211 for src_el in src.iter() {
212 data[idx] = (*src_el).cvt_into();
217 fn store_packed<T:Copy>(dst: &mut NAAudioBuffer<u8>, idx: usize, src: &Vec<T>, fmt: &NASoniton) where u8: FromFmt<T>, i16: FromFmt<T>, i32: FromFmt<T>, f32: FromFmt<T> {
218 if (fmt.bits & 7) != 0 { unimplemented!(); }
219 let bytes = (fmt.bits >> 3) as usize;
220 let mut offset = idx * bytes * src.len();
221 let data = dst.get_data_mut().unwrap();
223 for el in src.iter() {
224 let dst = &mut data[offset..];
226 match (bytes, fmt.be) {
228 dst[0] = u8::cvt_from(*el);
230 (2, true) => write_u16be(dst, i16::cvt_from(*el) as u16).unwrap(),
231 (2, false) => write_u16le(dst, i16::cvt_from(*el) as u16).unwrap(),
232 (3, true) => write_u24be(dst, (i32::cvt_from(*el) >> 8) as u32).unwrap(),
233 (3, false) => write_u24le(dst, (i32::cvt_from(*el) >> 8) as u32).unwrap(),
234 (4, true) => write_u32be(dst, i32::cvt_from(*el) as u32).unwrap(),
235 (4, false) => write_u32le(dst, i32::cvt_from(*el) as u32).unwrap(),
239 match (bytes, fmt.be) {
240 (4, true) => write_f32be(dst, f32::cvt_from(*el)).unwrap(),
241 (4, false) => write_f32le(dst, f32::cvt_from(*el)).unwrap(),
242 (8, true) => write_f64be(dst, f32::cvt_from(*el) as f64).unwrap(),
243 (8, false) => write_f64le(dst, f32::cvt_from(*el) as f64).unwrap(),
244 (_, _) => unreachable!(),
251 pub fn convert_audio_frame(src: &NABufferType, dst_info: &NAAudioInfo, dst_chmap: &NAChannelMap) ->
252 Result<NABufferType, SoundConvertError> {
253 let nsamples = src.get_audio_length();
255 return Err(SoundConvertError::InvalidInput);
257 let src_chmap = src.get_chmap().unwrap();
258 let src_info = src.get_audio_info().unwrap();
259 if (src_chmap.num_channels() == 0) || (dst_chmap.num_channels() == 0) {
260 return Err(SoundConvertError::InvalidInput);
263 let needs_remix = src_chmap.num_channels() != dst_chmap.num_channels();
264 let no_channel_needs = !needs_remix && channel_maps_equal(src_chmap, dst_chmap);
265 let needs_reorder = !needs_remix && !no_channel_needs && channel_maps_reordered(src_chmap, dst_chmap);
267 let channel_op = if no_channel_needs {
268 ChannelOp::Passthrough
269 } else if needs_reorder {
270 let reorder_mat = calculate_reorder_matrix(src_chmap, dst_chmap);
271 ChannelOp::Reorder(reorder_mat)
272 } else if src_chmap.num_channels() > 1 {
273 let remix_mat = calculate_remix_matrix(src_chmap, dst_chmap);
274 ChannelOp::Remix(remix_mat)
276 let mut dup_mat: Vec<bool> = Vec::with_capacity(dst_chmap.num_channels());
277 for i in 0..dst_chmap.num_channels() {
278 let ch = dst_chmap.get_channel(i);
279 if ch.is_left() || ch.is_right() || ch == NAChannelType::C {
285 ChannelOp::DupMono(dup_mat)
288 let src_fmt = src_info.get_format();
289 let dst_fmt = dst_info.get_format();
290 let no_conversion = src_fmt == dst_fmt;
292 if no_conversion && no_channel_needs {
293 return Ok(src.clone());
296 let ret = alloc_audio_buffer(dst_info.clone(), nsamples, dst_chmap.clone());
298 return Err(SoundConvertError::AllocError);
300 let mut dst_buf = ret.unwrap();
303 match (src, &mut dst_buf) {
304 (NABufferType::AudioU8(sb), NABufferType::AudioU8(ref mut db)) => {
305 let mut svec = vec![0; src_chmap.num_channels()];
306 let mut tvec1 = vec![0; src_chmap.num_channels()];
307 let mut tvec2 = vec![0; dst_chmap.num_channels()];
308 let mut dvec = vec![0; dst_chmap.num_channels()];
309 for i in 0..nsamples {
310 read_samples(sb, i, &mut svec);
311 if !channel_op.is_remix() {
312 apply_channel_op(&channel_op, &svec, &mut dvec);
314 for (oel, iel) in tvec1.iter_mut().zip(svec.iter()) {
315 *oel = (*iel as i32) - 128;
317 remix_i32(&channel_op, &tvec1, &mut tvec2);
318 for (oel, iel) in dvec.iter_mut().zip(tvec2.iter()) {
319 *oel = (*iel + 128).min(255).max(0) as u8;
322 store_samples(db, i, &dvec);
325 (NABufferType::AudioI16(sb), NABufferType::AudioI16(ref mut db)) => {
326 let mut svec = vec![0; src_chmap.num_channels()];
327 let mut tvec1 = vec![0; src_chmap.num_channels()];
328 let mut tvec2 = vec![0; dst_chmap.num_channels()];
329 let mut dvec = vec![0; dst_chmap.num_channels()];
330 for i in 0..nsamples {
331 read_samples(sb, i, &mut svec);
332 if !channel_op.is_remix() {
333 apply_channel_op(&channel_op, &svec, &mut dvec);
335 for (oel, iel) in tvec1.iter_mut().zip(svec.iter()) {
338 remix_i32(&channel_op, &tvec1, &mut tvec2);
339 for (oel, iel) in dvec.iter_mut().zip(tvec2.iter()) {
340 *oel = (*iel).min(16383).max(-16384) as i16;
343 store_samples(db, i, &dvec);
346 (NABufferType::AudioI32(sb), NABufferType::AudioI32(ref mut db)) => {
347 let mut svec = vec![0; src_chmap.num_channels()];
348 let mut dvec = vec![0; dst_chmap.num_channels()];
349 for i in 0..nsamples {
350 read_samples(sb, i, &mut svec);
351 if !channel_op.is_remix() {
352 apply_channel_op(&channel_op, &svec, &mut dvec);
354 remix_i32(&channel_op, &svec, &mut dvec);
356 store_samples(db, i, &dvec);
359 (NABufferType::AudioF32(sb), NABufferType::AudioF32(ref mut db)) => {
360 let mut svec = vec![0.0; src_chmap.num_channels()];
361 let mut dvec = vec![0.0; dst_chmap.num_channels()];
362 for i in 0..nsamples {
363 read_samples(sb, i, &mut svec);
364 if !channel_op.is_remix() {
365 apply_channel_op(&channel_op, &svec, &mut dvec);
367 remix_f32(&channel_op, &svec, &mut dvec);
369 store_samples(db, i, &dvec);
372 _ => unimplemented!(),
375 let into_float = dst_fmt.float;
377 let mut svec = vec![0i32; src_chmap.num_channels()];
378 let mut dvec = vec![0i32; dst_chmap.num_channels()];
379 for i in 0..nsamples {
381 NABufferType::AudioU8 (ref sb) => read_samples_i32(sb, i, &mut svec),
382 NABufferType::AudioI16(ref sb) => read_samples_i32(sb, i, &mut svec),
383 NABufferType::AudioI32(ref sb) => read_samples_i32(sb, i, &mut svec),
384 NABufferType::AudioF32(ref sb) => read_samples_i32(sb, i, &mut svec),
385 NABufferType::AudioPacked(ref sb) => read_packed(sb, i, &mut svec, &src_fmt),
388 if !channel_op.is_remix() {
389 apply_channel_op(&channel_op, &svec, &mut dvec);
391 remix_i32(&channel_op, &svec, &mut dvec);
394 NABufferType::AudioU8 (ref mut db) => store_samples(db, i, &dvec),
395 NABufferType::AudioI16(ref mut db) => store_samples(db, i, &dvec),
396 NABufferType::AudioI32(ref mut db) => store_samples(db, i, &dvec),
397 NABufferType::AudioF32(ref mut db) => store_samples(db, i, &dvec),
398 NABufferType::AudioPacked(ref mut buf) => store_packed(buf, i, &dvec, &dst_fmt),
403 let mut svec = vec![0.0f32; src_chmap.num_channels()];
404 let mut dvec = vec![0.0f32; dst_chmap.num_channels()];
405 for i in 0..nsamples {
407 NABufferType::AudioU8 (ref sb) => read_samples_f32(sb, i, &mut svec),
408 NABufferType::AudioI16(ref sb) => read_samples_f32(sb, i, &mut svec),
409 NABufferType::AudioI32(ref sb) => read_samples_f32(sb, i, &mut svec),
410 NABufferType::AudioF32(ref sb) => read_samples_f32(sb, i, &mut svec),
411 NABufferType::AudioPacked(ref sb) => read_packed(sb, i, &mut svec, &src_fmt),
414 if !channel_op.is_remix() {
415 apply_channel_op(&channel_op, &svec, &mut dvec);
417 remix_f32(&channel_op, &svec, &mut dvec);
420 NABufferType::AudioU8 (ref mut db) => store_samples(db, i, &dvec),
421 NABufferType::AudioI16(ref mut db) => store_samples(db, i, &dvec),
422 NABufferType::AudioI32(ref mut db) => store_samples(db, i, &dvec),
423 NABufferType::AudioF32(ref mut db) => store_samples(db, i, &dvec),
424 NABufferType::AudioPacked(ref mut buf) => store_packed(buf, i, &dvec, &dst_fmt),
434 pub fn channel_maps_equal(a: &NAChannelMap, b: &NAChannelMap) -> bool {
435 if a.num_channels() != b.num_channels() { return false; }
436 for i in 0..a.num_channels() {
437 if a.get_channel(i) != b.get_channel(i) {
444 pub fn channel_maps_reordered(a: &NAChannelMap, b: &NAChannelMap) -> bool {
445 if a.num_channels() != b.num_channels() { return false; }
446 let mut count_a = [0u8; 32];
447 let mut count_b = [0u8; 32];
448 for i in 0..a.num_channels() {
449 count_a[a.get_channel(i) as usize] += 1;
450 count_b[b.get_channel(i) as usize] += 1;
452 for (c0, c1) in count_a.iter().zip(count_b.iter()) {
460 pub fn calculate_reorder_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec<usize> {
461 if src.num_channels() != dst.num_channels() { return Vec::new(); }
462 let num_channels = src.num_channels();
463 let mut reorder: Vec<usize> = Vec::with_capacity(num_channels);
464 for i in 0..num_channels {
465 let dst_ch = dst.get_channel(i);
466 for j in 0..num_channels {
467 if src.get_channel(j) == dst_ch {
473 if reorder.len() != num_channels { reorder.clear(); }
477 fn is_stereo(chmap: &NAChannelMap) -> bool {
478 (chmap.num_channels() == 2) &&
479 (chmap.get_channel(0) == NAChannelType::L) &&
480 (chmap.get_channel(1) == NAChannelType::R)
483 pub fn calculate_remix_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec<f32> {
484 if is_stereo(src) && dst.num_channels() == 1 &&
485 (dst.get_channel(0) == NAChannelType::L || dst.get_channel(0) == NAChannelType::C) {
486 return vec![0.5, 0.5];
488 if src.num_channels() >= 5 && is_stereo(dst) {
489 let src_nch = src.num_channels();
490 let mut mat = vec![0.0f32; src_nch * 2];
491 let (l_mat, r_mat) = mat.split_at_mut(src_nch);
492 for ch in 0..src_nch {
493 match src.get_channel(ch) {
494 NAChannelType::L => l_mat[ch] = 1.0,
495 NAChannelType::R => r_mat[ch] = 1.0,
496 NAChannelType::C => { l_mat[ch] = SQRT_2 / 2.0; r_mat[ch] = SQRT_2 / 2.0; },
497 NAChannelType::Ls => l_mat[ch] = SQRT_2 / 2.0,
498 NAChannelType::Rs => r_mat[ch] = SQRT_2 / 2.0,
510 use std::str::FromStr;
511 use crate::formats::*;
515 let chcfg51 = NAChannelMap::from_str("L,R,C,LFE,Ls,Rs").unwrap();
516 let chcfg52 = NAChannelMap::from_str("C,L,R,Ls,Rs,LFE").unwrap();
517 let stereo = NAChannelMap::from_str("L,R").unwrap();
518 let reorder = calculate_reorder_matrix(&chcfg51, &chcfg52);
519 assert_eq!(reorder.as_slice(), [ 2, 0, 1, 4, 5, 3]);
520 let remix = calculate_remix_matrix(&chcfg51, &stereo);
521 assert_eq!(remix.as_slice(), [ 1.0, 0.0, SQRT_2 / 2.0, 0.0, SQRT_2 / 2.0, 0.0,
522 0.0, 1.0, SQRT_2 / 2.0, 0.0, 0.0, SQRT_2 / 2.0 ]);
525 fn test_conversion() {
526 const CHANNEL_VALUES: [u8; 6] = [ 140, 90, 130, 128, 150, 70 ];
527 let chcfg51 = NAChannelMap::from_str("L,R,C,LFE,Ls,Rs").unwrap();
528 let stereo = NAChannelMap::from_str("L,R").unwrap();
529 let src_ainfo = NAAudioInfo {
531 channels: chcfg51.num_channels() as u8,
532 format: SND_U8_FORMAT,
535 let mut dst_ainfo = NAAudioInfo {
537 channels: stereo.num_channels() as u8,
538 format: SND_S16P_FORMAT,
541 let mut src_frm = alloc_audio_buffer(src_ainfo, 42, chcfg51.clone()).unwrap();
542 if let NABufferType::AudioPacked(ref mut abuf) = src_frm {
543 let data = abuf.get_data_mut().unwrap();
546 for ch in 0..chcfg51.num_channels() {
547 data[idx] = CHANNEL_VALUES[ch];
552 panic!("wrong buffer type");
555 let out_frm = convert_audio_frame(&src_frm, &dst_ainfo, &stereo).unwrap();
556 if let NABufferType::AudioI16(ref abuf) = out_frm {
557 let off0 = abuf.get_offset(0);
558 let off1 = abuf.get_offset(1);
559 let data = abuf.get_data();
563 assert_eq!(r, -19943);
565 panic!("wrong buffer type");
568 dst_ainfo.format = SND_F32P_FORMAT;
569 let out_frm = convert_audio_frame(&src_frm, &dst_ainfo, &stereo).unwrap();
570 if let NABufferType::AudioF32(ref abuf) = out_frm {
571 let off0 = abuf.get_offset(0);
572 let off1 = abuf.get_offset(1);
573 let data = abuf.get_data();
576 assert_eq!(l, 0.22633252);
577 assert_eq!(r, -0.6062342);
579 panic!("wrong buffer type");