jamie/bwavfile
1
0
Fork 0
mirror of https://github.com/iluvcapra/bwavfile.git synced 2025-12-31 08:50:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cue lists in progress

Browse Source 
Need to clean up zero-terminated strings in adtl
This commit is contained in:
Jamie Hardt
2020-12-10 14:48:25 -08:00
parent c947904d0f
commit 8519854596
6 changed files with 88 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/cue.rs
View File

@@ -52,9 +52,8 @@ impl RawLabel {
text : {
let mut buf = vec![0u8; (length - 4) as usize ];
rdr.read_exact(&mut buf)?;
if buf.len() % 2 == 1 { rdr.read_u8()?; };
//if buf.len() % 2 == 1 { rdr.read_u8()?; };
buf
// String::from_utf8(buf).unwrap_or(String::from("<TEXT ENCODING ERROR>"))
}
})
}
@@ -76,9 +75,8 @@ impl RawNote {
text : {
let mut buf = vec![0u8; (length - 4) as usize ];
rdr.read_exact(&mut buf)?;
if length % 2 == 1 { rdr.read_u8()?; };
//if length % 2 == 1 { rdr.read_u8()?; };
buf
//String::from_utf8(buf).unwrap_or(String::from("<TEXT ENCODING ERROR>"))
}
})
}
@@ -113,7 +111,7 @@ impl RawLtxt {
if length - 20 > 0 {
let mut buf = vec![0u8; (length - 20) as usize];
rdr.read_exact(&mut buf)?;
if length % 2 == 1 { rdr.read_u8()?; };
//if length % 2 == 1 { rdr.read_u8()?; };
Some( buf )
//Some( String::from_utf8(buf).unwrap_or(String::from("<TEXT ENCODING ERROR>")) )
} else {
@@ -224,6 +222,7 @@ impl Cue {
raw_adtl = vec![];
}
Ok(
raw_cues.iter()
.map(|i| {

1
src/fourcc.rs
View File

@@ -105,6 +105,7 @@ pub const BEXT_SIG: FourCC = FourCC::make(b"bext");
pub const JUNK_SIG: FourCC = FourCC::make(b"JUNK");
pub const FLLR_SIG: FourCC = FourCC::make(b"FLLR");
pub const LIST_SIG: FourCC = FourCC::make(b"LIST");
pub const CUE__SIG: FourCC = FourCC::make(b"cue ");
pub const ADTL_SIG: FourCC = FourCC::make(b"adtl");

2
src/lib.rs
View File

@@ -15,6 +15,7 @@ production.
Apps we test against:
- Avid Pro Tools
- iZotope RX Audio Editor
- FFMpeg
- Audacity
@@ -130,3 +131,4 @@ pub use bext::Bext;
pub use fmt::{WaveFmt, WaveFmtExtended, ChannelDescriptor, ChannelMask};
pub use common_format::CommonFormat;
pub use audio_frame_reader::AudioFrameReader;
pub use cue::Cue;

11
src/list_form.rs
View File

@@ -21,11 +21,20 @@ pub fn collect_list_form(list_contents :& [u8]) -> Result<Vec<ListFormItem>, Err
while remain > 0 {
let this_sig = cursor.read_fourcc()?;
let this_size = cursor.read_u32::<LittleEndian>()? as usize;
remain -= 8;
let mut content_buf = vec![0u8; this_size];
cursor.read_exact(&mut content_buf)?;
remain -= this_size;
retval.push( ListFormItem { signature : this_sig, contents : content_buf } );
if this_size % 2 == 1 {
cursor.read_u8()?;
//panic!("Got this far!");
remain -= 1;
}
}
Ok( retval )
}

2
src/raw_chunk_reader.rs
View File

@@ -28,7 +28,7 @@ impl<'a,R: Read + Seek> RawChunkReader<'a, R> {
impl<'a, R:Read + Seek> Read for RawChunkReader<'_, R> {
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
if self.position >= self.length {
Err(Error::new(ErrorKind::UnexpectedEof, "RawChunkReader encountered end-of-file"))
Ok(0)
} else {
self.reader.seek(Start(self.start + self.position))?;
let to_read = min(self.length - self.position, buf.len() as u64);

77
src/wavereader.rs
View File

@@ -2,7 +2,7 @@
use std::fs::File;
use super::parser::Parser;
use super::fourcc::{FourCC, FMT__SIG,DATA_SIG, BEXT_SIG, JUNK_SIG, FLLR_SIG, CUE__SIG, ADTL_SIG};
use super::fourcc::{FourCC, ReadFourCC, FMT__SIG,DATA_SIG, BEXT_SIG, LIST_SIG, JUNK_SIG, FLLR_SIG, CUE__SIG, ADTL_SIG};
use super::errors::Error as ParserError;
use super::raw_chunk_reader::RawChunkReader;
use super::fmt::{WaveFmt, ChannelDescriptor, ChannelMask};
@@ -146,8 +146,9 @@ impl<R: Read + Seek> WaveReader<R> {
/// Returns a vector of channel descriptors, one for each channel
///
/// ```rust
/// # use bwavfile::WaveReader;
/// # use bwavfile::ChannelMask;
/// use bwavfile::WaveReader;
/// use bwavfile::ChannelMask;
///
/// let mut f = WaveReader::open("tests/media/pt_24bit_51.wav").unwrap();
///
/// let chans = f.channels().unwrap();
@@ -174,20 +175,36 @@ impl<R: Read + Seek> WaveReader<R> {
/// Read cue points.
///
/// ```rust
/// use bwavfile::WaveReader;
/// use bwavfile::Cue;
///
/// let mut f = WaveReader::open("tests/media/izotope_test.wav").unwrap();
/// let cue_points = f.cue_points().unwrap();
///
/// assert_eq!(cue_points.len(), 3);
/// assert_eq!(cue_points[0].ident, 1);
/// assert_eq!(cue_points[0].frame, 12532);
/// //assert_eq!(cue_points[0].label, Some(String::from("Marker 1")));
///
/// assert_eq!(cue_points[1].ident, 2);
/// assert_eq!(cue_points[1].frame, 20997);
///
/// assert_eq!(cue_points[2].ident, 3);
/// assert_eq!(cue_points[2].frame, 26711);
/// ```
pub fn cue_points(&mut self) -> Result<Vec<Cue>,ParserError> {
let mut cue_buffer : Vec<u8> = vec![];
let mut adtl_buffer : Vec<u8> = vec![];
let cue_read = self.read_chunk(CUE__SIG, 0, &mut cue_buffer)?;
let adtl_read = self.read_chunk(ADTL_SIG, 0, &mut adtl_buffer)?;
let adtl_read = self.read_list(ADTL_SIG, &mut adtl_buffer)?;
match (cue_read, adtl_read) {
(0,_) => Ok( vec![] ),
(_,0) => Ok( Cue::collect_from(&cue_buffer, None)? ),
(_,_) => Ok( Cue::collect_from(&cue_buffer, Some(&adtl_buffer) )? )
}
}
/// Read iXML data.
@@ -352,13 +369,26 @@ impl<R: Read + Seek> WaveReader<R> {
}
}
impl<R:Read+Seek> WaveReader<R> { /* Private Implementation */
impl<R:Read+Seek> WaveReader<R> {
// Private implementation
//
// As time passes thi get smore obnoxious because I haven't implemented recursive chunk
// parsing in the raw parser and I'm working around it
fn chunk_reader(&mut self, signature: FourCC, at_index: u32) -> Result<RawChunkReader<R>, ParserError> {
let (start, length) = self.get_chunk_extent_at_index(signature, at_index)?;
Ok( RawChunkReader::new(&mut self.inner, start, length) )
}
fn read_list(&mut self, ident: FourCC, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
if let Some(index) = self.get_list_form(ident)? {
self.read_chunk(LIST_SIG, index, buffer)
} else {
Ok( 0 )
}
}
fn read_chunk(&mut self, ident: FourCC, at: u32, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
let result = self.chunk_reader(ident, at);
@@ -374,14 +404,43 @@ impl<R:Read+Seek> WaveReader<R> { /* Private Implementation */
}
}
fn get_chunk_extent_at_index(&mut self, fourcc: FourCC, index: u32) -> Result<(u64,u64), ParserError> {
/// Extent of every chunk with the given fourcc
fn get_chunks_extents(&mut self, fourcc: FourCC) -> Result<Vec<(u64,u64)>, ParserError> {
let p = Parser::make(&mut self.inner)?.into_chunk_list()?;
if let Some(chunk) = p.iter().filter(|item| item.signature == fourcc).nth(index as usize) {
Ok ((chunk.start, chunk.length))
Ok( p.iter().filter(|item| item.signature == fourcc)
.map(|item| (item.start, item.length)).collect() )
}
/// Index of first LIST for with the given FORM fourcc
fn get_list_form(&mut self, fourcc: FourCC) -> Result<Option<u32>, ParserError> {
for (n, (start, length)) in self.get_chunks_extents(LIST_SIG)?.iter().enumerate() {
let mut reader = RawChunkReader::new(&mut self.inner, *start, *length);
let this_fourcc = reader.read_fourcc()?;
if this_fourcc == fourcc {
return Ok( Some( n as u32 ) );
}
}
Ok( None )
}
fn get_chunk_extent_at_index(&mut self, fourcc: FourCC, index: u32) -> Result<(u64,u64), ParserError> {
if let Some((start, length)) = self.get_chunks_extents(fourcc)?.iter().nth(index as usize) {
Ok ((*start, *length))
} else {
Err( ParserError::ChunkMissing { signature : fourcc } )
}
}
}
#[test]
fn test_list_form() {
let mut f = WaveReader::open("tests/media/izotope_test.wav").unwrap();
let mut buf : Vec<u8> = vec![];
f.read_list(ADTL_SIG, &mut buf).unwrap();
assert_ne!(buf.len(), 0);
}