use std::io::{Read, Write}; use super::errors::Error as ParserError; use encoding::{DecoderTrap, EncoderTrap}; use encoding::{Encoding}; use encoding::all::ASCII; use byteorder::LittleEndian; use byteorder::{ReadBytesExt, WriteBytesExt}; /** * References: * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/multichaudP.pdf */ #[derive(PartialEq)] enum FormatTags { Integer = 0x0001, Float = 0x0003, Extensible = 0xFFFE } const PCM_SUBTYPE_UUID: [u8; 16] = [0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71]; const FLOAT_SUBTYPE_UUID: [u8; 16] = [0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71]; /* https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/subformat-guids-for-compressed-audio-formats http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html These are from http://dream.cs.bath.ac.uk/researchdev/wave-ex/mulchaud.rtf */ #[derive(Debug)] pub enum WaveFmtExtendedChannelMask { FrontLeft = 0x1, FrontRight = 0x2, FrontCenter = 0x4, LowFrequency = 0x8, BackLeft = 0x10, BackRight = 0x20, FrontCenterLeft = 0x40, FrontCenterRight = 0x80, BackCenter = 0x100, SideLeft = 0x200, SideRight = 0x400, TopCenter = 0x800, TopFrontLeft = 0x1000, TopFrontCenter = 0x2000, TopFrontRight = 0x4000, TopBackLeft = 0x8000, TopBackCenter = 0x10000, TopBackRight = 0x20000 } /** * Extended Wave Format * * https://docs.microsoft.com/en-us/windows/win32/api/mmreg/ns-mmreg-waveformatextensible */ #[derive(Debug)] pub struct WaveFmtExtended { /// Valid bits per sample pub valid_bits_per_sample : u16, /// Channel mask /// /// Identifies the speaker assignment for each channel in the file pub channel_mask : WaveFmtExtendedChannelMask, /// Codec GUID /// /// Identifies the codec of the audio stream pub type_guid : [u8; 16], } /** * WAV file data format record. * * The `fmt` record contains essential information describing the binary * structure of the data segment of the WAVE file, such as sample * rate, sample binary format, channel count, etc. * */ #[derive(Debug)] pub struct WaveFmt { /// A tag identifying the codec in use. /// /// If this is 0xFFFE, the codec will be identified by a GUID /// in `extended_format` pub tag: u16, /// Count of audio channels in each frame pub channel_count: u16, /// Sample rate of the audio data pub sample_rate: u32, /// Count of bytes per second /// /// By rule, this is `block_alignment * sample_rate` pub bytes_per_second: u32, /// Count of bytes per audio frame /// /// By rule, this is `channel_count * bits_per_sample / 8` pub block_alignment: u16, /// Count of bits stored in the file per sample pub bits_per_sample: u16, /// Extended format description /// /// Additional format metadata if `channel_count` is greater than 2, /// or if certain codecs are used. pub extended_format: Option } impl WaveFmt { /// Create a new integer PCM format `WaveFmt` pub fn new_pcm(sample_rate: u32, bits_per_sample: u16, channel_count: u16) -> Self { let container_bits_per_sample = bits_per_sample + (bits_per_sample % 8); let container_bytes_per_sample= container_bits_per_sample / 8; let tag :u16 = match channel_count { 0 => panic!("Error"), 1..=2 => FormatTags::Integer as u16, _ => FormatTags::Extensible as u16, }; WaveFmt { tag, channel_count, sample_rate, bytes_per_second: container_bytes_per_sample as u32 * sample_rate * channel_count as u32, block_alignment: container_bytes_per_sample * channel_count, bits_per_sample: container_bits_per_sample, extended_format: None } } } /** * Broadcast-WAV metadata record. * * The `bext` record contains information about the original recording of the * Wave file, including a longish (256 ASCII chars) description field, * originator identification fields, creation calendar date and time, a * sample-accurate recording time field, and a SMPTE UMID. * * For a Wave file to be a complaint "Broadcast-WAV" file, it must contain * a `bext` metadata record. * * For reference on the structure and use of the BEXT record * check out [EBU Tech 3285](https://tech.ebu.ch/docs/tech/tech3285.pdf). */ #[derive(Debug)] pub struct Bext { pub description: String, pub originator: String, pub originator_reference: String, pub origination_date: String, pub origination_time: String, pub time_reference: u64, pub version: u16, pub umid: Option<[u8; 64]>, pub loudness_value: Option, pub loudness_range: Option, pub max_true_peak_level: Option, pub max_momentary_loudness: Option, pub max_short_term_loudness: Option, // 180 bytes of nothing pub coding_history: String } pub trait ReadBWaveChunks: Read { fn read_bext(&mut self) -> Result; fn read_bext_string_field(&mut self, length: usize) -> Result; fn read_wave_fmt(&mut self) -> Result; } pub trait WriteBWaveChunks: Write { fn write_wave_fmt(&mut self, format : &WaveFmt) -> Result<(), ParserError>; fn write_bext_string_field(&mut self, string: &String, length: usize) -> Result<(),ParserError>; fn write_bext(&mut self, bext: &Bext) -> Result<(),ParserError>; } impl WriteBWaveChunks for T where T: Write { fn write_wave_fmt(&mut self, format : &WaveFmt) -> Result<(), ParserError> { self.write_u16::(format.tag)?; self.write_u16::(format.channel_count)?; self.write_u32::(format.sample_rate)?; self.write_u32::(format.bytes_per_second)?; self.write_u16::(format.block_alignment)?; self.write_u16::(format.bits_per_sample)?; // self.write_u8(0)?; Ok(()) } fn write_bext_string_field(&mut self, string: &String, length: usize) -> Result<(),ParserError> { let mut buf = ASCII.encode(&string, EncoderTrap::Ignore).expect("Error encoding text"); buf.truncate(length); let filler_length = length - buf.len(); if filler_length > 0{ let mut filler = vec![0u8; filler_length ]; buf.append(&mut filler); } self.write_all(&buf)?; Ok(()) } fn write_bext(&mut self, bext: &Bext) -> Result<(),ParserError> { self.write_bext_string_field(&bext.description, 256)?; self.write_bext_string_field(&bext.originator, 32)?; self.write_bext_string_field(&bext.originator_reference, 32)?; self.write_bext_string_field(&bext.origination_date, 10)?; self.write_bext_string_field(&bext.origination_time, 8)?; self.write_u64::(bext.time_reference)?; self.write_u16::(bext.version)?; let buf = bext.umid.unwrap_or([0u8; 64]); self.write_all(&buf)?; self.write_i16::( (bext.loudness_value.unwrap_or(0.0) * 100.0) as i16 )?; self.write_i16::( (bext.loudness_range.unwrap_or(0.0) * 100.0) as i16 )?; self.write_i16::( (bext.max_true_peak_level.unwrap_or(0.0) * 100.0) as i16 )?; self.write_i16::( (bext.max_momentary_loudness.unwrap_or(0.0) * 100.0) as i16 )?; self.write_i16::( (bext.max_short_term_loudness.unwrap_or(0.0) * 100.0) as i16 )?; let padding = [0u8; 180]; self.write_all(&padding)?; let coding = ASCII.encode(&bext.coding_history, EncoderTrap::Ignore) .expect("Error"); self.write_all(&coding)?; Ok(()) } } impl ReadBWaveChunks for T where T: Read { fn read_wave_fmt(&mut self) -> Result { Ok(WaveFmt { tag: self.read_u16::()?, channel_count: self.read_u16::()?, sample_rate: self.read_u32::()?, bytes_per_second: self.read_u32::()?, block_alignment: self.read_u16::()?, bits_per_sample: self.read_u16::()?, extended_format: None }) } fn read_bext_string_field(&mut self, length: usize) -> Result { let mut buffer : Vec = vec![0; length]; self.read(&mut buffer)?; let trimmed : Vec = buffer.iter().take_while(|c| **c != 0 as u8).cloned().collect(); Ok(ASCII.decode(&trimmed, DecoderTrap::Ignore).expect("Error decoding text")) } fn read_bext(&mut self) -> Result { let version : u16; Ok( Bext { description: self.read_bext_string_field(256)?, originator: self.read_bext_string_field(32)?, originator_reference : self.read_bext_string_field(32)?, origination_date : self.read_bext_string_field(10)?, origination_time : self.read_bext_string_field(8)?, time_reference: self.read_u64::()?, version: { version = self.read_u16::()?; version }, umid: { let mut buf = [0u8 ; 64]; self.read(&mut buf)?; if version > 0 { Some(buf) } else { None } }, loudness_value: { let val = (self.read_i16::()? as f32) / 100f32; if version > 1 { Some(val) } else { None } }, loudness_range: { let val = self.read_i16::()? as f32 / 100f32; if version > 1 { Some(val) } else { None } }, max_true_peak_level: { let val = self.read_i16::()? as f32 / 100f32; if version > 1 { Some(val) } else { None } }, max_momentary_loudness: { let val = self.read_i16::()? as f32 / 100f32; if version > 1 { Some(val) } else { None } }, max_short_term_loudness: { let val = self.read_i16::()? as f32 / 100f32; if version > 1 { Some(val) } else { None } }, coding_history: { for _ in 0..=180 { self.read_u8()?; } let mut buf = vec![]; self.read_to_end(&mut buf)?; ASCII.decode(&buf, DecoderTrap::Ignore).expect("Error decoding text") } }) } }