diff --git a/src/audio_frame_reader.rs b/src/audio_frame_reader.rs index c0cf10b..b4d4a0f 100644 --- a/src/audio_frame_reader.rs +++ b/src/audio_frame_reader.rs @@ -1,5 +1,5 @@ use std::io::{Read, Seek}; -use std::io::SeekFrom::{Start,}; +use std::io::SeekFrom::{Start,Current,}; use byteorder::LittleEndian; use byteorder::ReadBytesExt; @@ -7,7 +7,6 @@ use byteorder::ReadBytesExt; use super::fmt::{WaveFmt}; use super::errors::Error; use super::CommonFormat; -use super::raw_chunk_reader::RawChunkReader; /// Read audio frames /// @@ -15,12 +14,14 @@ use super::raw_chunk_reader::RawChunkReader; /// bitstream having a format specified by `format`. /// #[derive(Debug)] -pub struct AudioFrameReader<'a, R: Read + Seek> { - inner : RawChunkReader<'a,R>, - format: WaveFmt +pub struct AudioFrameReader { + inner : R, + format: WaveFmt, + start: u64, + length: u64 } -impl<'a, R: Read + Seek> AudioFrameReader<'a, R> { +impl AudioFrameReader { /// Create a new `AudioFrameReader` /// @@ -30,16 +31,21 @@ impl<'a, R: Read + Seek> AudioFrameReader<'a, R> { /// parameter to confirm the `block_alignment` law is fulfilled /// and the format tag is readable by this implementation (only /// format 0x01 is supported at this time.) - pub fn new(inner: RawChunkReader<'a, R>, format: WaveFmt) -> Self { + pub fn new(mut inner: R, format: WaveFmt, start: u64, length: u64) -> Result { assert!(format.block_alignment * 8 == format.bits_per_sample * format.channel_count, "Unable to read audio frames from packed formats: block alignment is {}, should be {}", format.block_alignment, (format.bits_per_sample / 8 ) * format.channel_count); - assert!(format.common_format() == CommonFormat::IntegerPCM , "Unsupported format tag {:?}", format.tag); - - AudioFrameReader { inner , format } + + inner.seek(Start(start))?; + Ok( AudioFrameReader { inner , format , start, length} ) + } + + /// Unwrap the inner reader. + pub fn into_inner(self) -> R { + self.inner } /// Locate the read position to a different frame @@ -47,10 +53,13 @@ impl<'a, R: Read + Seek> AudioFrameReader<'a, R> { /// Seeks within the audio stream. /// /// Returns the new location of the read position. + /// + /// locate() behaves similarly to Read methods in that + /// seeking after the end of the audio data is not an error. pub fn locate(&mut self, to :u64) -> Result { let position = to * self.format.block_alignment as u64; - let seek_result = self.inner.seek(Start(position))?; - Ok( seek_result / self.format.block_alignment as u64 ) + let seek_result = self.inner.seek(Start(self.start + position))?; + Ok( (seek_result - self.start) / self.format.block_alignment as u64 ) } /// Create a frame buffer sized to hold frames of the reader @@ -69,7 +78,7 @@ impl<'a, R: Read + Seek> AudioFrameReader<'a, R> { /// Regardless of the number of bits in the audio sample, this method /// always writes `i32` samples back to the buffer. These samples are /// written back "right-aligned" so samples that are shorter than i32 - /// will leave the MSB bits empty. + /// will leave the MSB bits empty. /// /// For example: A full-code sample in 16 bit (0xFFFF) will be written /// back to the buffer as 0x0000FFFF. @@ -86,17 +95,22 @@ impl<'a, R: Read + Seek> AudioFrameReader<'a, R> { let framed_bits_per_sample = self.format.block_alignment * 8 / self.format.channel_count; - for n in 0..(self.format.channel_count as usize) { - buffer[n] = match (self.format.bits_per_sample, framed_bits_per_sample) { - (0..=8,8) => self.inner.read_u8()? as i32 - 0x80_i32, // EBU 3285 §A2.2 - (9..=16,16) => self.inner.read_i16::()? as i32, - (10..=24,24) => self.inner.read_i24::()?, - (25..=32,32) => self.inner.read_i32::()?, - (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", - b, self.format.channel_count, self.format.block_alignment) - } - } + let tell = self.inner.seek(Current(0))?; - Ok( 1 ) + if (tell - self.start) < self.length { + for n in 0..(self.format.channel_count as usize) { + buffer[n] = match (self.format.bits_per_sample, framed_bits_per_sample) { + (0..=8,8) => self.inner.read_u8()? as i32 - 0x80_i32, // EBU 3285 §A2.2 + (9..=16,16) => self.inner.read_i16::()? as i32, + (10..=24,24) => self.inner.read_i24::()?, + (25..=32,32) => self.inner.read_i32::()?, + (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", + b, self.format.channel_count, self.format.block_alignment) + } + } + Ok( 1 ) + } else { + Ok( 0 ) + } } } \ No newline at end of file diff --git a/src/raw_chunk_reader.rs b/src/raw_chunk_reader.rs index 7922a7d..e292d6a 100644 --- a/src/raw_chunk_reader.rs +++ b/src/raw_chunk_reader.rs @@ -9,8 +9,8 @@ use std::io::{Seek,Read,Error,ErrorKind}; #[derive(Debug)] pub struct RawChunkReader<'a, R: Read + Seek> { reader: &'a mut R, - start: u64, - length: u64, + pub start: u64, + pub length: u64, position: u64 } @@ -23,10 +23,6 @@ impl<'a,R: Read + Seek> RawChunkReader<'a, R> { position: 0 } } - - pub fn length(&self) -> u64 { - self.length - } } impl<'a, R:Read + Seek> Read for RawChunkReader<'_, R> { diff --git a/src/wavereader.rs b/src/wavereader.rs index d1699c5..6a99416 100644 --- a/src/wavereader.rs +++ b/src/wavereader.rs @@ -100,13 +100,13 @@ impl WaveReader { return self.inner; } - /** - * Create an `AudioFrameReader` for reading each audio frame. - */ - pub fn audio_frame_reader(&mut self) -> Result, ParserError> { + /// + /// Create an `AudioFrameReader` for reading each audio frame and consume the `WaveReader`. + /// + pub fn audio_frame_reader(mut self) -> Result, ParserError> { let format = self.format()?; - let audio_chunk_reader = self.chunk_reader(DATA_SIG, 0)?; - Ok(AudioFrameReader::new(audio_chunk_reader, format)) + let audio_chunk_reader = self.get_chunk_extent_at_index(DATA_SIG, 0)?; + Ok(AudioFrameReader::new(self.inner, format, audio_chunk_reader.0, audio_chunk_reader.1)?) } /** diff --git a/tests/integration_test.rs b/tests/integration_test.rs index 74e7a28..1fa4d86 100644 --- a/tests/integration_test.rs +++ b/tests/integration_test.rs @@ -81,7 +81,7 @@ fn test_minimal_wave() { fn test_read() { let path = "tests/media/audacity_16bit.wav"; - let mut w = WaveReader::open(path).expect("Failure opening test file"); + let w = WaveReader::open(path).expect("Failure opening test file"); let mut reader = w.audio_frame_reader().unwrap(); @@ -99,7 +99,7 @@ fn test_read() { fn test_locate_multichannel_read() { let path = "tests/media/ff_pink.wav"; - let mut w = WaveReader::open(path).expect("Failure opening test file"); + let w = WaveReader::open(path).expect("Failure opening test file"); let mut reader = w.audio_frame_reader().unwrap(); @@ -158,21 +158,22 @@ fn test_channels_stereo_no_fmt_extended() { assert_eq!(channels[1].speaker,ChannelMask::FrontRight); } -// THis is me playing around trying to work on #6 and #7 -// -// #[test] -// fn test_sample_reader_type() { -// // Issue #6 -// use bwavfile::WaveFmt; -// use bwavfile::AudioFrameReader; +//See issue 6 and 7 +#[test] +fn test_frame_reader_consumes_reader() { + // Issue #6 + use bwavfile::WaveFmt; + use bwavfile::AudioFrameReader; + use std::fs::File; + fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader), ()> { + if let Ok(mut r) = WaveReader::open(&wav_filename) { + let format = r.format().unwrap(); + let frame_reader = r.audio_frame_reader().unwrap(); + Ok((format, frame_reader)) + } else { + Err(()) + } + } -// fn from_wav_filename<'a>(wav_filename: &str) -> Result<(WaveReader, WaveFmt, AudioFrameReader<'a, std::fs::File>), ()> { -// if let Ok(mut r) = WaveReader::open(&wav_filename) { -// let format = r.format().unwrap(); -// let frame_reader = r.audio_frame_reader().unwrap(); -// Ok((r, format, frame_reader)) -// } else { -// Err(()) -// } -// } -// } \ No newline at end of file + let _result = from_wav_filename("tests/media/pt_24bit_stereo.wav").unwrap(); +} \ No newline at end of file