use std::path::Path;
use anyhow::{Context, Result};
use crate::resampler::resample;
const OPUS_ENCODER_FRAME_SIZE: usize = 960;
const OPUS_SAMPLE_RATE: u32 = 48000;
#[allow(unused)]
#[derive(Debug)]
struct OpusHeader {
version: u8,
channel_count: u8,
pre_skip: u16,
input_sample_rate: u32,
output_gain: i16,
mapping_family: u8,
}
fn write_opus_header<W: std::io::Write>(
w: &mut W,
channels: u8,
sample_rate: u32,
pre_skip: u16,
) -> std::io::Result<()> {
use byteorder::WriteBytesExt;
w.write_all(b"OpusHead")?;
w.write_u8(1)?; w.write_u8(channels)?; w.write_u16::<byteorder::LittleEndian>(pre_skip)?; w.write_u32::<byteorder::LittleEndian>(sample_rate)?; w.write_i16::<byteorder::LittleEndian>(0)?; w.write_u8(0)?; Ok(())
}
fn write_opus_tags<W: std::io::Write>(w: &mut W) -> std::io::Result<()> {
use byteorder::WriteBytesExt;
let vendor = "rust";
w.write_all(b"OpusTags")?;
w.write_u32::<byteorder::LittleEndian>(
u32::try_from(vendor.len()).expect("static Opus vendor fits in u32"),
)?; w.write_all(vendor.as_bytes())?; w.write_u32::<byteorder::LittleEndian>(0u32)?; Ok(())
}
fn write_ogg_48khz<W: std::io::Write>(
w: &mut W,
pcm: &[f32],
input_sample_rate: u32,
stereo: bool,
) -> Result<()> {
let mut pw = ogg::PacketWriter::new(w);
let channels = if stereo { 2 } else { 1 };
anyhow::ensure!(
pcm.len().is_multiple_of(channels),
"PCM sample count must be divisible by the channel count"
);
let mut encoder = {
let channels = if stereo {
opus::Channels::Stereo
} else {
opus::Channels::Mono
};
opus::Encoder::new(OPUS_SAMPLE_RATE, channels, opus::Application::Voip)?
};
let pre_skip = u16::try_from(encoder.get_lookahead()?)
.context("Opus encoder returned an invalid lookahead")?;
let mut head = Vec::new();
write_opus_header(
&mut head,
u8::try_from(channels).expect("Opus supports at most two channels"),
input_sample_rate,
pre_skip,
)?;
pw.write_packet(head, 42, ogg::PacketWriteEndInfo::EndPage, 0)?;
let mut tags = Vec::new();
write_opus_tags(&mut tags)?;
pw.write_packet(tags, 42, ogg::PacketWriteEndInfo::EndPage, 0)?;
let mut out_encoded = vec![0u8; 50_000];
let input_frames = pcm.len() / channels;
let frames_to_encode = input_frames + pre_skip as usize;
let encoded_frames = frames_to_encode.div_ceil(OPUS_ENCODER_FRAME_SIZE);
let mut padded_pcm = vec![0.0; encoded_frames * OPUS_ENCODER_FRAME_SIZE * channels];
padded_pcm[..pcm.len()].copy_from_slice(pcm);
for (frame_index, frame) in padded_pcm
.chunks_exact(OPUS_ENCODER_FRAME_SIZE * channels)
.enumerate()
{
let size = encoder.encode_float(frame, &mut out_encoded)?;
let msg = out_encoded[..size].to_vec();
let is_last = frame_index + 1 == encoded_frames;
let end_info = if is_last {
ogg::PacketWriteEndInfo::EndStream
} else {
ogg::PacketWriteEndInfo::NormalPacket
};
let granule_position = if is_last {
u64::try_from(input_frames).context("input contains too many frames")?
+ u64::from(pre_skip)
} else {
((frame_index + 1) * OPUS_ENCODER_FRAME_SIZE) as u64
};
pw.write_packet(msg, 42, end_info, granule_position)?;
}
Ok(())
}
pub fn write_ogg_mono<W: std::io::Write>(w: &mut W, pcm: &[f32], sample_rate: u32) -> Result<()> {
if sample_rate == OPUS_SAMPLE_RATE {
write_ogg_48khz(w, pcm, sample_rate, false)
} else {
let pcm = resample(pcm, sample_rate as usize, OPUS_SAMPLE_RATE as usize)?;
write_ogg_48khz(w, &pcm, sample_rate, false)
}
}
pub fn write_opus(filename: impl AsRef<Path>, data: &[f32], sample_rate: u32) -> Result<()> {
let w = std::fs::File::create(filename.as_ref())?;
let mut w = std::io::BufWriter::new(w);
write_ogg_mono(&mut w, data, sample_rate)?;
Ok(())
}
#[cfg(test)]
#[allow(
clippy::cast_possible_truncation,
clippy::cast_precision_loss,
clippy::cast_sign_loss
)] mod tests {
use super::*;
#[test]
fn test_write_opus_header() {
let mut buffer = Vec::new();
let result = write_opus_header(&mut buffer, 1, 16000, 312);
assert!(result.is_ok());
assert_eq!(&buffer[0..8], b"OpusHead");
assert_eq!(buffer[8], 1); assert_eq!(buffer[9], 1); }
#[test]
fn test_write_opus_header_stereo() {
let mut buffer = Vec::new();
let result = write_opus_header(&mut buffer, 2, 48000, 312);
assert!(result.is_ok());
assert_eq!(&buffer[0..8], b"OpusHead");
assert_eq!(buffer[8], 1); assert_eq!(buffer[9], 2); }
#[test]
fn test_write_opus_tags() {
let mut buffer = Vec::new();
let result = write_opus_tags(&mut buffer);
assert!(result.is_ok());
assert_eq!(&buffer[0..8], b"OpusTags");
assert_eq!(buffer[8], 4);
assert_eq!(buffer[9], 0);
assert_eq!(buffer[10], 0);
assert_eq!(buffer[11], 0);
assert_eq!(&buffer[12..16], b"rust");
}
#[test]
fn test_opus_constants() {
assert_eq!(OPUS_ENCODER_FRAME_SIZE, 960);
assert_eq!(OPUS_SAMPLE_RATE, 48000);
}
#[test]
fn test_write_ogg_mono_with_silence() {
let sample_rate = 48000;
let duration_frames = 10;
let pcm: Vec<f32> = vec![0.0; OPUS_ENCODER_FRAME_SIZE * duration_frames];
let mut buffer = Vec::new();
let result = write_ogg_mono(&mut buffer, &pcm, sample_rate);
assert!(result.is_ok());
assert!(!buffer.is_empty(), "Output buffer should contain data");
}
#[test]
fn test_write_ogg_mono_with_tone() {
let sample_rate = 48000;
let duration_frames = 5;
let frequency = 440.0;
let pcm: Vec<f32> = (0..OPUS_ENCODER_FRAME_SIZE * duration_frames)
.map(|i| {
let t = i as f32 / sample_rate as f32;
(2.0 * std::f32::consts::PI * frequency * t).sin() * 0.5
})
.collect();
let mut buffer = Vec::new();
let result = write_ogg_mono(&mut buffer, &pcm, sample_rate);
assert!(result.is_ok());
assert!(!buffer.is_empty(), "Output buffer should contain data");
}
#[test]
fn test_write_ogg_mono_pads_short_input_and_ends_stream() {
let pcm = vec![0.25; 100];
let mut buffer = Vec::new();
write_ogg_mono(&mut buffer, &pcm, OPUS_SAMPLE_RATE).unwrap();
let mut reader = ogg::PacketReader::new(std::io::Cursor::new(buffer));
let mut packets = Vec::new();
while let Some(packet) = reader.read_packet().unwrap() {
packets.push(packet);
}
assert!(packets.len() >= 3, "expected headers and an audio packet");
assert!(packets.last().unwrap().last_in_stream());
let pre_skip = u16::from_le_bytes([packets[0].data[10], packets[0].data[11]]);
assert_eq!(
packets.last().unwrap().absgp_page(),
pcm.len() as u64 + u64::from(pre_skip)
);
}
#[test]
fn test_write_ogg_mono_requires_resampling() {
let sample_rate = 16000;
let duration_frames = 5;
let num_samples = (sample_rate as f32 / OPUS_SAMPLE_RATE as f32
* OPUS_ENCODER_FRAME_SIZE as f32) as usize
* duration_frames;
let pcm: Vec<f32> = vec![0.5; num_samples];
let mut buffer = Vec::new();
let result = write_ogg_mono(&mut buffer, &pcm, sample_rate);
assert!(result.is_ok());
assert!(
!buffer.is_empty(),
"Output buffer should contain data after resampling"
);
}
#[test]
fn test_opus_header_structure() {
let mut buffer = Vec::new();
write_opus_header(&mut buffer, 1, 16000, 312).unwrap();
assert_eq!(buffer.len(), 19);
assert_eq!(&buffer[0..8], b"OpusHead");
assert_eq!(buffer[8], 1);
assert_eq!(buffer[9], 1);
let pre_skip = u16::from_le_bytes([buffer[10], buffer[11]]);
assert_eq!(pre_skip, 312);
let sample_rate = u32::from_le_bytes([buffer[12], buffer[13], buffer[14], buffer[15]]);
assert_eq!(sample_rate, 16000);
let output_gain = i16::from_le_bytes([buffer[16], buffer[17]]);
assert_eq!(output_gain, 0);
assert_eq!(buffer[18], 0);
}
#[test]
fn test_opus_tags_structure() {
let mut buffer = Vec::new();
write_opus_tags(&mut buffer).unwrap();
assert_eq!(&buffer[0..8], b"OpusTags");
let vendor_length = u32::from_le_bytes([buffer[8], buffer[9], buffer[10], buffer[11]]);
assert_eq!(vendor_length, 4);
assert_eq!(&buffer[12..16], b"rust");
let num_comments = u32::from_le_bytes([buffer[16], buffer[17], buffer[18], buffer[19]]);
assert_eq!(num_comments, 0);
}
}