src/wavwriter.rs

   1 extern crate nihav;
   2
   3 use nihav::io::byteio::*;
   4 use nihav::frame::*;
   5 use std::fs::File;
   6 use std::io::SeekFrom;
   7
   8 pub struct WavWriter<'a> {
   9     io: Box<ByteWriter<'a>>,
  10     data_pos: u64,
  11 }
  12
  13 fn write_byte(wr: &mut ByteWriter, sample: u8) -> ByteIOResult<()> {
  14     wr.write_byte(sample)
  15 }
  16
  17 fn write_s16(wr: &mut ByteWriter, sample: i16) -> ByteIOResult<()> {
  18     wr.write_u16le(sample as u16)
  19 }
  20
  21 fn write_s32(wr: &mut ByteWriter, sample: i32) -> ByteIOResult<()> {
  22     wr.write_u16le((sample >> 16) as u16)
  23 }
  24
  25 fn write_f32(wr: &mut ByteWriter, sample: f32) -> ByteIOResult<()> {
  26     let mut out = (sample * 32768.0) as i32;
  27     if out < -32768 { out = -32768; }
  28     if out >  32767 { out =  32767; }
  29     if out < 0 { out += 65536; }
  30     wr.write_u16le(out as u16)
  31 }
  32
  33 macro_rules! write_data {
  34     ($wr:expr, $buf:expr, $write:ident) => ({
  35         let len = $buf.get_length();
  36         let ainfo = $buf.get_info();
  37         let nch = ainfo.get_channels() as usize;
  38         let mut offs: Vec<usize> = Vec::with_capacity(nch);
  39         for ch in 0..nch { offs.push($buf.get_offset(ch)); }
  40         let data = $buf.get_data();
  41
  42         for i in 0..len {
  43             for ch in 0..nch {
  44                 let sample = data[offs[ch] + i];
  45                 $write($wr, sample)?;
  46             }
  47         }
  48     })
  49 }
  50
  51 impl<'a> WavWriter<'a> {
  52     pub fn new(name: &String) -> Self {
  53         let file = File::create(name).unwrap();
  54         let fw   = Box::new(FileWriter::new_write(file));
  55         let io   = ByteWriter::new(Box::leak(fw));
  56         WavWriter { io: Box::new(io), data_pos: 0 }
  57     }
  58     pub fn write_header(&mut self, ainfo: NAAudioInfo) -> ByteIOResult<()> {
  59         let bits = ainfo.get_format().get_bits() as usize;
  60
  61         self.io.write_buf(b"RIFF")?;
  62         self.io.write_u32le(0)?;
  63         self.io.write_buf(b"WAVE")?;
  64
  65         self.io.write_buf(b"fmt ")?;
  66         self.io.write_u32le(16)?;
  67         self.io.write_u16le(0x0001)?; // PCM
  68         self.io.write_u16le(ainfo.get_channels() as u16)?;
  69         self.io.write_u32le(ainfo.get_sample_rate() as u32)?;
  70
  71         if bits < 16 {
  72             self.io.write_u32le((ainfo.get_channels() as u32) * (ainfo.get_sample_rate() as u32))?;
  73             self.io.write_u16le(ainfo.get_channels() as u16)?; // block align
  74             self.io.write_u16le(8)?;
  75         } else {
  76             self.io.write_u32le(2 * (ainfo.get_channels() as u32) * (ainfo.get_sample_rate() as u32))?;
  77             self.io.write_u16le((2 * ainfo.get_channels()) as u16)?; // block align
  78             self.io.write_u16le(16)?;
  79         }
  80
  81         self.io.write_buf(b"data")?;
  82         self.io.write_u32le(0)?;
  83
  84         self.data_pos = self.io.tell();
  85         Ok(())
  86     }
  87     pub fn write_frame(&mut self, abuf: NABufferType) -> ByteIOResult<()> {
  88         match abuf {
  89             NABufferType::AudioU8(ref buf) => {
  90                 write_data!(&mut self.io, buf, write_byte);
  91             }
  92             NABufferType::AudioI16(ref buf) => {
  93                 write_data!(&mut self.io, buf, write_s16);
  94             }
  95             NABufferType::AudioI32(ref buf) => {
  96                 write_data!(&mut self.io, buf, write_s32);
  97             }
  98             NABufferType::AudioF32(ref buf) => {
  99                 write_data!(&mut self.io, buf, write_f32);
 100             }
 101             NABufferType::AudioPacked(ref buf) => {
 102                 self.io.write_buf(buf.get_data().as_slice())?;
 103             }
 104             _ => {},
 105         };
 106         Ok(())
 107     }
 108 }
 109
 110 impl<'a> Drop for WavWriter<'a> {
 111     #[allow(unused_variables)]
 112     fn drop(&mut self) {
 113         let size = self.io.tell();
 114         if (self.data_pos > 0) && (size >= self.data_pos) {
 115             let res = self.io.seek(SeekFrom::Start(4));
 116             let res = self.io.write_u32le((size - 8) as u32);
 117             let res = self.io.seek(SeekFrom::Start(self.data_pos - 4));
 118             let res = self.io.write_u32le(((size as u64) - self.data_pos) as u32);
 119         }
 120     }
 121 }