1 use nihav_core::frame::*;
2 use nihav_core::soundcvt::*;
13 fn copy_audio<T:Clone+Copy>(dst: &mut [T], dstride: usize,
14 src: &[T], sstride: usize,
15 len: usize, channels: usize)
17 match (sstride == 1, dstride == 1) {
19 for (dchan, schan) in dst.chunks_mut(dstride).zip(
20 src.chunks(sstride)).take(channels) {
21 dchan[..len].copy_from_slice(&schan[..len]);
25 for (ch, schan) in src.chunks(sstride).take(channels).enumerate() {
26 for (dchunk, &samp) in dst[ch..].chunks_mut(channels).zip(schan.iter()).take(len / channels) {
32 for (i, frame) in src.chunks_exact(channels).take(len).enumerate() {
33 for (&samp, dchan) in frame.iter().zip(dst[i..].chunks_mut(dstride)) {
39 dst[..len].copy_from_slice(&src[..len]);
44 impl<T:Clone+Copy+From<u8>> AudioQueue<T> {
45 fn new(channels: usize, rec_size: usize, ileaved: bool) -> Self {
49 stride: if ileaved { rec_size * channels } else { rec_size },
52 data: vec![0.into(); rec_size * channels],
55 fn get_cur_size(&self) -> usize { self.end - self.start }
56 fn get_length(&self) -> usize {
57 let size = self.get_cur_size();
64 fn get_cur_avail(&self) -> usize { self.stride - self.end }
65 fn get_potentially_avail(&self) -> usize { self.stride - self.get_cur_size() }
66 fn read(&mut self, src: &NAAudioBuffer<T>) {
67 let mut to_copy = src.get_length();
69 to_copy *= self.channels;
71 if self.get_cur_avail() < to_copy {
72 if self.get_potentially_avail() >= to_copy {
75 let new_len = (self.stride * 2).max(self.get_cur_size() + src.get_length());
76 let mut new_buf = vec![0.into(); new_len * self.channels];
77 let new_stride = if !self.ileaved { new_len } else { new_len * self.channels };
79 let old_len = self.get_cur_size();
80 let new_len = src.get_length();
83 for (dst, (old, new)) in new_buf.chunks_exact_mut(new_stride).zip(
84 self.data.chunks_exact(self.stride).zip(
85 src.get_data().chunks(src.get_stride()))) {
86 dst[..old_len].copy_from_slice(&old[self.start..self.end]);
87 dst[old_len..][..new_len].copy_from_slice(&new[..new_len]);
90 new_buf[..old_len].copy_from_slice(&self.data[self.start..self.end]);
91 copy_audio(&mut new_buf[old_len..], 1, src.get_data(), src.get_stride(), new_len, self.channels);
94 copy_audio(&mut new_buf, if !self.ileaved { new_stride } else { 1 }, src.get_data(), src.get_stride(), new_len, self.channels);
97 self.stride = new_stride;
99 self.end = old_len + new_len;
103 copy_audio(&mut self.data[self.end..], if !self.ileaved { self.stride } else { 1 }, src.get_data(), src.get_stride(),
104 to_copy, self.channels);
107 fn write(&mut self, dbuf: &mut NAAudioBuffer<T>) {
108 let mut dst_len = dbuf.get_length();
109 let dst_stride = dbuf.get_stride();
110 let dst = dbuf.get_data_mut().unwrap();
113 dst_len *= self.channels;
115 copy_audio(dst, dst_stride, &self.data[self.start..], if !self.ileaved { self.stride } else { 1 },
116 dst_len, self.channels);
117 self.start += dst_len;
119 fn renorm(&mut self) {
124 let move_size = self.end - self.start;
126 for chan in self.data.chunks_exact_mut(self.stride) {
127 for i in 0..move_size {
128 chan[i] = chan[self.start + i];
132 self.end -= self.start;
139 I16(AudioQueue<i16>),
140 I32(AudioQueue<i32>),
141 F32(AudioQueue<f32>),
142 Packed(AudioQueue<u8>),
146 fn get_length(&self) -> usize {
148 AudioDataType::U8(ref queue) => queue.get_length(),
149 AudioDataType::I16(ref queue) => queue.get_length(),
150 AudioDataType::I32(ref queue) => queue.get_length(),
151 AudioDataType::F32(ref queue) => queue.get_length(),
152 AudioDataType::Packed(ref queue) => queue.get_length(),
157 pub struct AudioConverter {
158 queue: AudioDataType,
159 dst_fmt: NAAudioInfo,
160 dst_chmap: NAChannelMap,
162 resampler: NAResample,
165 impl AudioConverter {
166 pub fn new(sinfo: &NAAudioInfo, dinfo: &NAAudioInfo, dst_chmap: NAChannelMap) -> Self {
167 let ch = usize::from(dinfo.channels);
168 let size = dinfo.block_len * 2;
169 let il = !dinfo.format.planar;
170 let queue = match (dinfo.format.bits, dinfo.format.float, dinfo.format.signed) {
171 ( 8, false, false) => AudioDataType::U8(AudioQueue::new(ch, size, il)),
172 (16, false, true) => AudioDataType::I16(AudioQueue::new(ch, size, il)),
173 (32, false, true) => AudioDataType::I32(AudioQueue::new(ch, size, il)),
174 (32, true, _) => AudioDataType::F32(AudioQueue::new(ch, size, il)),
175 _ => AudioDataType::Packed(AudioQueue::new(ch, size, il)),
177 const RESAMPLE_FILTER_ORDER: usize = 16;
178 let resampler = NAResample::new(sinfo.sample_rate, dinfo, &dst_chmap, RESAMPLE_FILTER_ORDER);
187 pub fn queue_frame(&mut self, buf: NABufferType, tinfo: NATimeInfo) -> bool {
188 let ret = self.resampler.convert_audio_frame(&buf);
189 if let Ok(dbuf) = ret {
190 if self.apts.is_none() && tinfo.get_pts().is_some() {
191 self.apts = tinfo.get_pts();
193 match (&mut self.queue, dbuf) {
194 (AudioDataType::U8(ref mut queue), NABufferType::AudioU8(ref buf)) => queue.read(buf),
195 (AudioDataType::I16(ref mut queue), NABufferType::AudioI16(ref buf)) => queue.read(buf),
196 (AudioDataType::I32(ref mut queue), NABufferType::AudioI32(ref buf)) => queue.read(buf),
197 (AudioDataType::F32(ref mut queue), NABufferType::AudioF32(ref buf)) => queue.read(buf),
198 (AudioDataType::Packed(ref mut queue), NABufferType::AudioPacked(ref buf)) => queue.read(buf),
199 _ => unimplemented!(),
206 pub fn get_frame(&mut self, info: NACodecInfoRef) -> Option<NAFrame> {
207 if self.queue.get_length() >= self.dst_fmt.block_len {
208 if let Ok(mut abuf) = alloc_audio_buffer(self.dst_fmt, self.dst_fmt.block_len, self.dst_chmap.clone()) {
209 match (&mut self.queue, &mut abuf) {
210 (AudioDataType::U8(ref mut queue), NABufferType::AudioU8(ref mut buf)) => queue.write(buf),
211 (AudioDataType::I16(ref mut queue), NABufferType::AudioI16(ref mut buf)) => queue.write(buf),
212 (AudioDataType::I32(ref mut queue), NABufferType::AudioI32(ref mut buf)) => queue.write(buf),
213 (AudioDataType::F32(ref mut queue), NABufferType::AudioF32(ref mut buf)) => queue.write(buf),
214 (AudioDataType::Packed(ref mut queue), NABufferType::AudioPacked(ref mut buf)) => queue.write(buf),
215 _ => unimplemented!(),
217 let tinfo = NATimeInfo::new(self.apts, None, Some(self.dst_fmt.block_len as u64), 1, self.dst_fmt.sample_rate);
218 if let Some(ref mut val) = self.apts {
219 *val += self.dst_fmt.block_len as u64;
221 Some(NAFrame::new(tinfo, FrameType::I, true, info, abuf))
223 println!(" failed to allocate audio frame");