gst-plugins-rs/audio/audiofx/tests/hrtfrender.rs

287 lines
8.3 KiB
Rust

// Copyright (C) 2021 Tomasz Andrzejak <andreiltd@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
use gst::glib;
use gst::prelude::*;
use once_cell::sync::Lazy;
use std::io::{Cursor, Write};
static CONFIG: Lazy<glib::Bytes> = Lazy::new(|| {
let mut buff = Cursor::new(vec![0u8; 1024]);
write_config(&mut buff).unwrap();
glib::Bytes::from_owned(buff.get_ref().to_owned())
});
// Generates a fake config
fn write_config(writer: &mut impl Write) -> std::io::Result<()> {
const SAMPLE_RATE: u32 = 44_100;
const LENGTH: u32 = 2;
const VERTEX_COUNT: u32 = 2;
const INDEX_COUNT: u32 = 2 * 3;
writer.write_all(b"HRIR")?;
writer.write_all(&SAMPLE_RATE.to_le_bytes())?;
writer.write_all(&LENGTH.to_le_bytes())?;
writer.write_all(&VERTEX_COUNT.to_le_bytes())?;
writer.write_all(&INDEX_COUNT.to_le_bytes())?;
// Write Indices
for _ in 0..INDEX_COUNT {
writer.write_all(&0u32.to_le_bytes())?;
}
// Write Vertices
for _ in 0..VERTEX_COUNT {
for _ in 0..3 {
writer.write_all(&0u32.to_le_bytes())?;
}
for _ in 0..LENGTH * 2 {
writer.write_all(&0f32.to_le_bytes())?;
}
}
Ok(())
}
fn init() {
use std::sync::Once;
static INIT: Once = Once::new();
INIT.call_once(|| {
gst::init().unwrap();
gstrsaudiofx::plugin_register_static().expect("Failed to register rsaudiofx plugin");
});
}
fn build_harness(src_caps: gst::Caps, sink_caps: gst::Caps) -> (gst_check::Harness, gst::Element) {
let hrtf = gst::ElementFactory::make("hrtfrender", None).unwrap();
hrtf.set_property("hrir-raw", &*CONFIG);
let mut h = gst_check::Harness::with_element(&hrtf, Some("sink"), Some("src"));
h.set_caps(src_caps, sink_caps);
(h, hrtf)
}
#[test]
fn test_hrtfrender_samples_in_samples_out() {
init();
let src_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 1i32)
.field("channel-mask", gst::Bitmask::new(0x1))
.field("layout", "interleaved")
.build();
let sink_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 2i32)
.field("layout", "interleaved")
.build();
let (mut h, _) = build_harness(src_caps, sink_caps);
h.play();
let inbpf = 4;
let outbpf = 8;
let full_block = 512 * 8;
let mut buffer = gst::Buffer::with_size(full_block * inbpf + 20 * inbpf).unwrap();
let buffer_mut = buffer.get_mut().unwrap();
let full_block_time = (full_block as u64)
.mul_div_round(*gst::ClockTime::SECOND, 44_100)
.map(gst::ClockTime::from_nseconds);
buffer_mut.set_pts(gst::ClockTime::ZERO);
buffer_mut.set_duration(full_block_time);
buffer_mut.set_offset(0);
let ret = h.push(buffer);
assert!(ret.is_ok());
let buffer = h.pull().unwrap();
assert_eq!(buffer.size(), full_block * outbpf);
h.push_event(gst::event::Eos::new());
let buffer = h.pull().unwrap();
assert_eq!(buffer.size(), 20 * outbpf);
assert_eq!(buffer.offset(), full_block as u64);
assert_eq!(buffer.pts(), full_block_time);
let residue_time = 20
.mul_div_round(*gst::ClockTime::SECOND, 44_100)
.map(gst::ClockTime::from_nseconds);
assert_eq!(buffer.duration(), residue_time);
}
#[test]
fn test_hrtfrender_implicit_spatial_objects() {
init();
let src_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 8i32)
.field("channel-mask", gst::Bitmask::new(0xc3f))
.field("layout", "interleaved")
.build();
let sink_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 2i32)
.field("layout", "interleaved")
.build();
let (mut h, hrtf) = build_harness(src_caps, sink_caps);
let objs = hrtf.property::<gst::Array>("spatial-objects");
h.play();
assert_eq!(objs.len(), 8);
}
#[test]
fn test_hrtfrender_explicit_spatial_objects() {
init();
let src_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 8i32)
.field("layout", "interleaved")
.build();
let sink_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 2i32)
.field("layout", "interleaved")
.build();
let (mut h, hrtf) = build_harness(src_caps, sink_caps);
let objs = (0..8)
.map(|x| {
gst::Structure::builder("application/spatial-object")
.field("x", -1f32 + x as f32 / 8f32)
.field("y", 0f32)
.field("z", 1f32)
.field("distance-gain", 0.1f32)
.build()
})
.collect::<Vec<_>>();
hrtf.set_property("spatial-objects", gst::Array::new(objs));
h.play();
let objs = hrtf.property::<gst::Array>("spatial-objects");
assert_eq!(objs.len(), 8);
}
#[test]
// Caps negotation should fail if we have mismatch between input channels and
// of objects that we set via property. In this test case input has 6 channels
// but the number of spatial objects set is 2.
fn test_hrtfrender_caps_negotiation_fail() {
init();
let src_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 6i32)
.field("layout", "interleaved")
.build();
let sink_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 2i32)
.field("layout", "interleaved")
.build();
let (mut h, hrtf) = build_harness(src_caps, sink_caps);
let objs = (0..2)
.map(|_| {
gst::Structure::builder("application/spatial-object")
.field("x", 0f32)
.field("y", 0f32)
.field("z", 1f32)
.field("distance-gain", 0.1f32)
.build()
})
.collect::<Vec<_>>();
hrtf.set_property("spatial-objects", gst::Array::new(objs));
h.play();
let buffer = gst::Buffer::with_size(2048).unwrap();
assert_eq!(h.push(buffer), Err(gst::FlowError::NotNegotiated));
h.push_event(gst::event::Eos::new());
// The harness sinkpad end up not having defined caps so, the current_caps
// should be None
let current_caps = h.sinkpad().expect("harness has no sinkpad").current_caps();
assert!(current_caps.is_none());
}
#[test]
fn test_hrtfrender_multiple_instances_sharing_thread_pool() {
init();
let src_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 1i32)
.field("layout", "interleaved")
.build();
let sink_caps = gst::Caps::builder("audio/x-raw")
.field("format", gst_audio::AUDIO_FORMAT_F32.to_str())
.field("rate", 44_100i32)
.field("channels", 2i32)
.field("layout", "interleaved")
.build();
let (_, hrtf) = build_harness(src_caps.clone(), sink_caps.clone());
let block_length: u64 = hrtf.property::<u64>("block-length");
let steps: u64 = hrtf.property::<u64>("interpolation-steps");
let bps: u64 = 4;
drop(hrtf);
let blksz = (block_length * steps * bps) as usize;
let mut harnesses = (0..4)
.map(|_| build_harness(src_caps.clone(), sink_caps.clone()).0)
.collect::<Vec<_>>();
for h in harnesses.iter_mut() {
h.play();
let buffer = gst::Buffer::with_size(blksz).unwrap();
assert!(h.push(buffer).is_ok());
let buffer = h.pull().unwrap();
assert_eq!(buffer.size(), 2 * blksz);
h.push_event(gst::event::Eos::new());
}
}