X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fsoundcvt%2Fmod.rs;h=b218e4ae588d61b2f9c60ffed77fe4ba230adac9;hb=b36f412c24813b14cb2b1f8fd151863e2a49c1e2;hp=bc34b23da0e386a25b4ed6bfbf9961f802cb3452;hpb=8809c626d8dbe3c3f09f15396410680cc4c1fbba;p=nihav.git diff --git a/nihav-core/src/soundcvt/mod.rs b/nihav-core/src/soundcvt/mod.rs index bc34b23..b218e4a 100644 --- a/nihav-core/src/soundcvt/mod.rs +++ b/nihav-core/src/soundcvt/mod.rs @@ -1,3 +1,7 @@ +//! Sound format conversion. +//! +//! This module implements the functionality for conversion between different sound formats: packed or planar audio, 8-/16-/24-/32-bit, integer or floating point, different number of channels. +//! Eventually this might support resampling as well. pub use crate::formats::{NASoniton,NAChannelMap}; pub use crate::frame::{NAAudioBuffer,NAAudioInfo,NABufferType}; use crate::formats::NAChannelType; @@ -5,10 +9,14 @@ use crate::frame::alloc_audio_buffer; use crate::io::byteio::*; use std::f32::consts::SQRT_2; +/// A list specifying general sound conversion errors. #[derive(Clone,Copy,Debug,PartialEq)] pub enum SoundConvertError { + /// Invalid input arguments. InvalidInput, + /// Allocation failed. AllocError, + /// Requested feature is not supported. Unsupported, } @@ -29,10 +37,10 @@ impl ChannelOp { } } -fn apply_channel_op(ch_op: &ChannelOp, src: &Vec, dst: &mut Vec) { +fn apply_channel_op(ch_op: &ChannelOp, src: &[T], dst: &mut Vec) { match *ch_op { ChannelOp::Passthrough => { - dst.copy_from_slice(src.as_slice()); + dst.copy_from_slice(src); }, ChannelOp::Reorder(ref reorder) => { for (out, idx) in dst.iter_mut().zip(reorder.iter()) { @@ -43,7 +51,7 @@ fn apply_channel_op(ch_op: &ChannelOp, src: &Vec, dst: &mut Vec) { }; } -fn remix_i32(ch_op: &ChannelOp, src: &Vec, dst: &mut Vec) { +fn remix_i32(ch_op: &ChannelOp, src: &[i32], dst: &mut Vec) { if let ChannelOp::Remix(ref remix_mat) = ch_op { let sch = src.len(); for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) { @@ -62,7 +70,7 @@ fn remix_i32(ch_op: &ChannelOp, src: &Vec, dst: &mut Vec) { } } -fn remix_f32(ch_op: &ChannelOp, src: &Vec, dst: &mut Vec) { +fn remix_f32(ch_op: &ChannelOp, src: &[f32], dst: &mut Vec) { if let ChannelOp::Remix(ref remix_mat) = ch_op { let sch = src.len(); for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) { @@ -89,13 +97,13 @@ impl FromFmt for u8 { fn cvt_from(val: u8) -> u8 { val } } impl FromFmt for i16 { - fn cvt_from(val: u8) -> i16 { ((val as i16) - 128).wrapping_mul(0x101) } + fn cvt_from(val: u8) -> i16 { (i16::from(val) - 128).wrapping_mul(0x101) } } impl FromFmt for i32 { - fn cvt_from(val: u8) -> i32 { ((val as i32) - 128).wrapping_mul(0x01010101) } + fn cvt_from(val: u8) -> i32 { (i32::from(val) - 128).wrapping_mul(0x01010101) } } impl FromFmt for f32 { - fn cvt_from(val: u8) -> f32 { ((val as f32) - 128.0) / 128.0 } + fn cvt_from(val: u8) -> f32 { (f32::from(val) - 128.0) / 128.0 } } impl FromFmt for u8 { @@ -105,10 +113,10 @@ impl FromFmt for i16 { fn cvt_from(val: i16) -> i16 { val } } impl FromFmt for i32 { - fn cvt_from(val: i16) -> i32 { (val as i32).wrapping_mul(0x10001) } + fn cvt_from(val: i16) -> i32 { i32::from(val).wrapping_mul(0x10001) } } impl FromFmt for f32 { - fn cvt_from(val: i16) -> f32 { (val as f32) / 32768.0 } + fn cvt_from(val: i16) -> f32 { f32::from(val) / 32768.0 } } impl FromFmt for u8 { @@ -225,8 +233,8 @@ impl SampleReader for PackedSampleReader<'_> { } trait SampleWriter { - fn store_samples_i32(&mut self, pos: usize, src: &Vec); - fn store_samples_f32(&mut self, pos: usize, src: &Vec); + fn store_samples_i32(&mut self, pos: usize, src: &[i32]); + fn store_samples_f32(&mut self, pos: usize, src: &[f32]); } struct GenericSampleWriter<'a, T:Copy> { @@ -235,14 +243,14 @@ struct GenericSampleWriter<'a, T:Copy> { } impl<'a, T:Copy+FromFmt+FromFmt> SampleWriter for GenericSampleWriter<'a, T> { - fn store_samples_i32(&mut self, pos: usize, src: &Vec) { + fn store_samples_i32(&mut self, pos: usize, src: &[i32]) { let mut off = pos; for el in src.iter() { self.data[off] = (*el).cvt_into(); off += self.stride; } } - fn store_samples_f32(&mut self, pos: usize, src: &Vec) { + fn store_samples_f32(&mut self, pos: usize, src: &[f32]) { let mut off = pos; for el in src.iter() { self.data[off] = (*el).cvt_into(); @@ -264,7 +272,7 @@ impl<'a> PackedSampleWriter<'a> { Self { data, fmt, bpp } } - fn store_samples(&mut self, pos: usize, src: &Vec) where u8: FromFmt, i16: FromFmt, i32: FromFmt, f32: FromFmt { + fn store_samples(&mut self, pos: usize, src: &[T]) where u8: FromFmt, i16: FromFmt, i32: FromFmt, f32: FromFmt { let mut offset = pos * self.bpp * src.len(); for el in src.iter() { let dst = &mut self.data[offset..]; @@ -285,8 +293,8 @@ impl<'a> PackedSampleWriter<'a> { match (self.bpp, self.fmt.be) { (4, true) => write_f32be(dst, f32::cvt_from(*el)).unwrap(), (4, false) => write_f32le(dst, f32::cvt_from(*el)).unwrap(), - (8, true) => write_f64be(dst, f32::cvt_from(*el) as f64).unwrap(), - (8, false) => write_f64le(dst, f32::cvt_from(*el) as f64).unwrap(), + (8, true) => write_f64be(dst, f64::from(f32::cvt_from(*el))).unwrap(), + (8, false) => write_f64le(dst, f64::from(f32::cvt_from(*el))).unwrap(), (_, _) => unreachable!(), }; } @@ -296,15 +304,16 @@ impl<'a> PackedSampleWriter<'a> { } impl SampleWriter for PackedSampleWriter<'_> { - fn store_samples_i32(&mut self, pos: usize, src: &Vec) { + fn store_samples_i32(&mut self, pos: usize, src: &[i32]) { self.store_samples(pos, src); } - fn store_samples_f32(&mut self, pos: usize, src: &Vec) { + fn store_samples_f32(&mut self, pos: usize, src: &[f32]) { self.store_samples(pos, src); } } -pub fn convert_audio_frame(src: &NABufferType, dst_info: &NAAudioInfo, dst_chmap: &NAChannelMap) -> +/// Converts input audio buffer into desired format and returns a newly allocated buffer. +pub fn convert_audio_frame(src: &NABufferType, dst_info: &NAAudioInfo, dst_chmap: &NAChannelMap) -> Result { let mut nsamples = src.get_audio_length(); if nsamples == 0 { @@ -353,12 +362,14 @@ Result { return Ok(src.clone()); } - let ret = alloc_audio_buffer(dst_info.clone(), nsamples, dst_chmap.clone()); + let ret = alloc_audio_buffer(*dst_info, nsamples, dst_chmap.clone()); if ret.is_err() { return Err(SoundConvertError::AllocError); } let mut dst_buf = ret.unwrap(); + let sstep = src.get_audio_step().max(1); + let dstep = dst_buf.get_audio_step().max(1); let sr: Box = match src { NABufferType::AudioU8(ref ab) => { let stride = ab.get_stride(); @@ -418,33 +429,42 @@ Result { if !into_float { let mut svec = vec![0; src_chmap.num_channels()]; let mut dvec = vec![0; dst_chmap.num_channels()]; - for i in 0..nsamples { - sr.get_samples_i32(i, &mut svec); + let mut spos = 0; + let mut dpos = 0; + for _ in 0..nsamples { + sr.get_samples_i32(spos, &mut svec); if !channel_op.is_remix() { apply_channel_op(&channel_op, &svec, &mut dvec); } else { remix_i32(&channel_op, &svec, &mut dvec); } - sw.store_samples_i32(i, &dvec); + sw.store_samples_i32(dpos, &dvec); + spos += sstep; + dpos += dstep; } } else { let mut svec = vec![0.0; src_chmap.num_channels()]; let mut dvec = vec![0.0; dst_chmap.num_channels()]; - for i in 0..nsamples { - sr.get_samples_f32(i, &mut svec); + let mut spos = 0; + let mut dpos = 0; + for _ in 0..nsamples { + sr.get_samples_f32(spos, &mut svec); if !channel_op.is_remix() { apply_channel_op(&channel_op, &svec, &mut dvec); } else { remix_f32(&channel_op, &svec, &mut dvec); } - sw.store_samples_f32(i, &dvec); + sw.store_samples_f32(dpos, &dvec); + spos += sstep; + dpos += dstep; } } drop(sw); - + Ok(dst_buf) } +/// Checks whether two channel maps are identical. pub fn channel_maps_equal(a: &NAChannelMap, b: &NAChannelMap) -> bool { if a.num_channels() != b.num_channels() { return false; } for i in 0..a.num_channels() { @@ -455,6 +475,7 @@ pub fn channel_maps_equal(a: &NAChannelMap, b: &NAChannelMap) -> bool { true } +/// Checks whether two channel maps have identical channels (but maybe in different order). pub fn channel_maps_reordered(a: &NAChannelMap, b: &NAChannelMap) -> bool { if a.num_channels() != b.num_channels() { return false; } let mut count_a = [0u8; 32]; @@ -471,6 +492,7 @@ pub fn channel_maps_reordered(a: &NAChannelMap, b: &NAChannelMap) -> bool { true } +/// Calculates permutation matrix for reordering channels from source channel map into destination one. pub fn calculate_reorder_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec { if src.num_channels() != dst.num_channels() { return Vec::new(); } let num_channels = src.num_channels(); @@ -490,10 +512,11 @@ pub fn calculate_reorder_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec bool { (chmap.num_channels() == 2) && - (chmap.get_channel(0) == NAChannelType::L) && + (chmap.get_channel(0) == NAChannelType::L) && (chmap.get_channel(1) == NAChannelType::R) } +/// Calculates matrix of remixing coefficients for converting input channel layout into destination one. pub fn calculate_remix_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec { if is_stereo(src) && dst.num_channels() == 1 && (dst.get_channel(0) == NAChannelType::L || dst.get_channel(0) == NAChannelType::C) { @@ -553,7 +576,7 @@ mod test { block_len: 512, }; let mut src_frm = alloc_audio_buffer(src_ainfo, 42, chcfg51.clone()).unwrap(); - if let NABufferType::AudioPacked(ref mut abuf) = src_frm { + if let NABufferType::AudioU8(ref mut abuf) = src_frm { let data = abuf.get_data_mut().unwrap(); let mut idx = 0; for _ in 0..42 {