Browse Source

Merge pull request #104 from rust3ds/improve/ndsp

Improve Ndsp API
pull/112/head
Meziu 2 years ago committed by GitHub
parent
commit
0b295ce0f6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 19
      ctru-rs/examples/audio-filters.rs
  2. 190
      ctru-rs/src/services/ndsp/mod.rs
  3. 47
      ctru-rs/src/services/ndsp/wave.rs

19
ctru-rs/examples/audio-filters.rs

@ -5,13 +5,13 @@ use std::f32::consts::PI; @@ -5,13 +5,13 @@ use std::f32::consts::PI;
use ctru::linear::LinearAllocator;
use ctru::prelude::*;
use ctru::services::ndsp::{
wave::{WaveInfo, WaveStatus},
AudioFormat, InterpolationType, Ndsp, OutputMode,
wave::{Wave, WaveStatus},
AudioFormat, AudioMix, InterpolationType, Ndsp, OutputMode,
};
const SAMPLE_RATE: usize = 22050;
const SAMPLES_PER_BUF: usize = SAMPLE_RATE / 10; // 2205
const BYTES_PER_SAMPLE: usize = 4;
const BYTES_PER_SAMPLE: usize = AudioFormat::PCM16Stereo.size();
const AUDIO_WAVE_LENGTH: usize = SAMPLES_PER_BUF * BYTES_PER_SAMPLE;
// Note Frequencies
@ -65,8 +65,8 @@ fn main() { @@ -65,8 +65,8 @@ fn main() {
let audio_data2 = audio_data1.clone();
let mut wave_info1 = WaveInfo::new(audio_data1, AudioFormat::PCM16Stereo, false);
let mut wave_info2 = WaveInfo::new(audio_data2, AudioFormat::PCM16Stereo, false);
let mut wave_info1 = Wave::new(audio_data1, AudioFormat::PCM16Stereo, false);
let mut wave_info2 = Wave::new(audio_data2, AudioFormat::PCM16Stereo, false);
let mut ndsp = Ndsp::init().expect("Couldn't obtain NDSP controller");
@ -79,10 +79,7 @@ fn main() { @@ -79,10 +79,7 @@ fn main() {
channel_zero.set_format(AudioFormat::PCM16Stereo);
// Output at 100% on the first pair of left and right channels.
let mut mix: [f32; 12] = [0f32; 12];
mix[0] = 1.0;
mix[1] = 1.0;
let mix = AudioMix::default();
channel_zero.set_mix(&mix);
channel_zero.queue_wave(&mut wave_info1).unwrap();
@ -142,13 +139,13 @@ fn main() { @@ -142,13 +139,13 @@ fn main() {
}
}
let current: &mut WaveInfo = if altern {
let current: &mut Wave = if altern {
&mut wave_info1
} else {
&mut wave_info2
};
let status = current.get_status();
let status = current.status();
if let WaveStatus::Done = status {
fill_buffer(current.get_buffer_mut().unwrap(), NOTEFREQ[note]);

190
ctru-rs/src/services/ndsp/mod.rs

@ -1,12 +1,13 @@ @@ -1,12 +1,13 @@
//! NDSP (Audio) service
pub mod wave;
use wave::{WaveInfo, WaveStatus};
use wave::{Wave, WaveStatus};
use crate::error::ResultCode;
use crate::services::ServiceReference;
use std::cell::{RefCell, RefMut};
use std::default::Default;
use std::error;
use std::fmt;
use std::sync::Mutex;
@ -30,6 +31,12 @@ pub enum AudioFormat { @@ -30,6 +31,12 @@ pub enum AudioFormat {
PCM16Stereo = ctru_sys::NDSP_FORMAT_STEREO_PCM16,
}
/// Representation of volume mix for a channel.
#[derive(Copy, Clone, Debug)]
pub struct AudioMix {
raw: [f32; 12],
}
#[derive(Copy, Clone, Debug)]
#[repr(u32)]
pub enum InterpolationType {
@ -47,7 +54,7 @@ pub enum NdspError { @@ -47,7 +54,7 @@ pub enum NdspError {
/// Channel ID
WaveBusy(u8),
/// Sample amount requested, Max sample amount
SampleCountOutOfBounds(u32, u32),
SampleCountOutOfBounds(usize, usize),
}
pub struct Channel<'ndsp> {
@ -141,17 +148,19 @@ impl Channel<'_> { @@ -141,17 +148,19 @@ impl Channel<'_> {
}
// Returns the channel's id
pub fn get_id(&self) -> u8 {
pub fn id(&self) -> u8 {
self.id
}
/// Returns the channel's current sample's position.
pub fn get_sample_position(&self) -> u32 {
unsafe { ctru_sys::ndspChnGetSamplePos(self.id.into()) }
/// Returns the index of the currently played sample.
///
/// Because of how fast this value changes, it should only be used as a rough estimate of the current progress.
pub fn sample_position(&self) -> usize {
(unsafe { ctru_sys::ndspChnGetSamplePos(self.id.into()) }) as usize
}
/// Returns the channel's current wave sequence's id.
pub fn get_wave_sequence_id(&self) -> u16 {
pub fn wave_sequence_id(&self) -> u16 {
unsafe { ctru_sys::ndspChnGetWaveBufSeq(self.id.into()) }
}
@ -172,19 +181,8 @@ impl Channel<'_> { @@ -172,19 +181,8 @@ impl Channel<'_> {
}
/// Set the channel's volume mix.
///
/// # Notes
///
/// The buffer's format is read as:
///
/// Index 0: Front left volume <br>
/// Index 1: Front right volume <br>
/// Index 2: Back left volume <br>
/// Index 3: Back right volume <br>
/// Index 4..7: Same as 0..3 but for auxiliary output 0 <br>
/// Index 8..11: Same as 0..3 but for auxiliary output 1 <br>
pub fn set_mix(&self, mix: &[f32; 12]) {
unsafe { ctru_sys::ndspChnSetMix(self.id.into(), mix.as_ptr().cast_mut()) }
pub fn set_mix(&self, mix: &AudioMix) {
unsafe { ctru_sys::ndspChnSetMix(self.id.into(), mix.as_raw().as_ptr().cast_mut()) }
}
/// Set the channel's rate of sampling.
@ -206,10 +204,10 @@ impl Channel<'_> { @@ -206,10 +204,10 @@ impl Channel<'_> {
///
/// # Warning
///
/// `libctru` expects the user to manually keep the info data (in this case [WaveInfo]) alive during playback.
/// To ensure safety, checks within [WaveInfo] will clear the whole channel queue if any queued [WaveInfo] is dropped prematurely.
pub fn queue_wave(&self, wave: &mut WaveInfo) -> std::result::Result<(), NdspError> {
match wave.get_status() {
/// `libctru` expects the user to manually keep the info data (in this case [Wave]) alive during playback.
/// To ensure safety, checks within [Wave] will clear the whole channel queue if any queued [Wave] is dropped prematurely.
pub fn queue_wave(&self, wave: &mut Wave) -> std::result::Result<(), NdspError> {
match wave.status() {
WaveStatus::Playing | WaveStatus::Queued => return Err(NdspError::WaveBusy(self.id)),
_ => (),
}
@ -302,15 +300,137 @@ impl Channel<'_> { @@ -302,15 +300,137 @@ impl Channel<'_> {
impl AudioFormat {
/// Returns the amount of bytes needed to store one sample
///
/// Eg.
/// 8 bit formats return 1 (byte)
/// 16 bit formats return 2 (bytes)
pub fn sample_size(self) -> u8 {
/// 8 bit mono formats return 1 (byte)
/// 16 bit stereo (dual-channel) formats return 4 (bytes)
pub const fn size(self) -> usize {
match self {
AudioFormat::PCM8Mono => 1,
AudioFormat::PCM16Mono | AudioFormat::PCM8Stereo => 2,
AudioFormat::PCM16Stereo => 4,
Self::PCM8Mono => 1,
Self::PCM16Mono | Self::PCM8Stereo => 2,
Self::PCM16Stereo => 4,
}
}
}
impl AudioMix {
/// Creates a new [AudioMix] with all volumes set to 0.
pub fn zeroed() -> Self {
Self { raw: [0.; 12] }
}
/// Returns a reference to the raw data.
pub fn as_raw(&self) -> &[f32; 12] {
&self.raw
}
/// Returns a mutable reference to the raw data.
pub fn as_raw_mut(&mut self) -> &mut [f32; 12] {
&mut self.raw
}
/// Returns the values set for the "front" volume mix (left and right channel).
pub fn front(&self) -> (f32, f32) {
(self.raw[0], self.raw[1])
}
/// Returns the values set for the "back" volume mix (left and right channel).
pub fn back(&self) -> (f32, f32) {
(self.raw[2], self.raw[3])
}
/// Returns the values set for the "front" volume mix (left and right channel) for the specified auxiliary output device (either 0 or 1).
pub fn aux_front(&self, id: usize) -> (f32, f32) {
if id > 1 {
panic!("invalid auxiliary output device index")
}
let index = 4 + id * 4;
(self.raw[index], self.raw[index + 1])
}
/// Returns the values set for the "back" volume mix (left and right channel) for the specified auxiliary output device (either 0 or 1).
pub fn aux_back(&self, id: usize) -> (f32, f32) {
if id > 1 {
panic!("invalid auxiliary output device index")
}
let index = 6 + id * 4;
(self.raw[index], self.raw[index + 1])
}
/// Sets the values for the "front" volume mix (left and right channel).
///
/// # Notes
///
/// [Channel] will normalize the mix values to be within 0 and 1.
/// However, an [AudioMix] instance with larger/smaller values is valid.
pub fn set_front(&mut self, left: f32, right: f32) {
self.raw[0] = left;
self.raw[1] = right;
}
/// Sets the values for the "back" volume mix (left and right channel).
///
/// # Notes
///
/// [Channel] will normalize the mix values to be within 0 and 1.
/// However, an [AudioMix] instance with larger/smaller values is valid.
pub fn set_back(&mut self, left: f32, right: f32) {
self.raw[2] = left;
self.raw[3] = right;
}
/// Sets the values for the "front" volume mix (left and right channel) for the specified auxiliary output device (either 0 or 1).
///
/// # Notes
///
/// [Channel] will normalize the mix values to be within 0 and 1.
/// However, an [AudioMix] instance with larger/smaller values is valid.
pub fn set_aux_front(&mut self, left: f32, right: f32, id: usize) {
if id > 1 {
panic!("invalid auxiliary output device index")
}
let index = 4 + id * 4;
self.raw[index] = left;
self.raw[index + 1] = right;
}
/// Sets the values for the "back" volume mix (left and right channel) for the specified auxiliary output device (either 0 or 1).
///
/// # Notes
///
/// [Channel] will normalize the mix values to be within 0 and 1.
/// However, an [AudioMix] instance with larger/smaller values is valid.
pub fn set_aux_back(&mut self, left: f32, right: f32, id: usize) {
if id > 1 {
panic!("invalid auxiliary output device index")
}
let index = 6 + id * 4;
self.raw[index] = left;
self.raw[index + 1] = right;
}
}
/// Returns an [AudioMix] object with "front left" and "front right" volumes set to 100%, and all other volumes set to 0%.
impl Default for AudioMix {
fn default() -> Self {
let mut mix = AudioMix::zeroed();
mix.set_front(1.0, 1.0);
mix
}
}
impl From<[f32; 12]> for AudioMix {
fn from(value: [f32; 12]) -> Self {
Self { raw: value }
}
}
@ -319,7 +439,7 @@ impl fmt::Display for NdspError { @@ -319,7 +439,7 @@ impl fmt::Display for NdspError {
match self {
Self::InvalidChannel(id) => write!(f, "audio Channel with ID {id} doesn't exist. Valid channels have an ID between 0 and 23"),
Self::ChannelAlreadyInUse(id) => write!(f, "audio Channel with ID {id} is already being used. Drop the other instance if you want to use it here"),
Self::WaveBusy(id) => write!(f, "the selected WaveInfo is busy playing on channel {id}"),
Self::WaveBusy(id) => write!(f, "the selected Wave is busy playing on channel {id}"),
Self::SampleCountOutOfBounds(samples_requested, max_samples) => write!(f, "the sample count requested is too big (requested = {samples_requested}, maximum = {max_samples})"),
}
}
@ -327,16 +447,10 @@ impl fmt::Display for NdspError { @@ -327,16 +447,10 @@ impl fmt::Display for NdspError {
impl error::Error for NdspError {}
impl<'ndsp> Drop for Channel<'ndsp> {
fn drop(&mut self) {
self.reset();
}
}
impl Drop for Ndsp {
fn drop(&mut self) {
for i in 0..NUMBER_OF_CHANNELS {
self.channel(i).unwrap().clear_queue();
self.channel(i).unwrap().reset();
}
}
}

47
ctru-rs/src/services/ndsp/wave.rs

@ -1,8 +1,8 @@ @@ -1,8 +1,8 @@
use super::{AudioFormat, NdspError};
use crate::linear::LinearAllocator;
/// Informational struct holding the raw audio data and playback info. This corresponds to [ctru_sys::ndspWaveBuf]
pub struct WaveInfo {
/// Informational struct holding the raw audio data and playback info. This corresponds to [ctru_sys::ndspWaveBuf].
pub struct Wave {
/// Data block of the audio wave (and its format information).
buffer: Box<[u8], LinearAllocator>,
audio_format: AudioFormat,
@ -13,7 +13,7 @@ pub struct WaveInfo { @@ -13,7 +13,7 @@ pub struct WaveInfo {
#[derive(Copy, Clone, Debug)]
#[repr(u8)]
/// Enum representing the playback status of a [WaveInfo].
/// Enum representing the playback status of a [Wave].
pub enum WaveStatus {
Free = ctru_sys::NDSP_WBUF_FREE as u8,
Queued = ctru_sys::NDSP_WBUF_QUEUED as u8,
@ -21,14 +21,14 @@ pub enum WaveStatus { @@ -21,14 +21,14 @@ pub enum WaveStatus {
Done = ctru_sys::NDSP_WBUF_DONE as u8,
}
impl WaveInfo {
impl Wave {
/// Build a new playable wave object from a raw buffer on LINEAR memory and a some info.
pub fn new(
buffer: Box<[u8], LinearAllocator>,
audio_format: AudioFormat,
looping: bool,
) -> Self {
let sample_count: usize = buffer.len() / (audio_format.sample_size() as usize);
let sample_count = buffer.len() / audio_format.size();
// Signal to the DSP processor the buffer's RAM sector.
// This step may seem delicate, but testing reports failure most of the time, while still having no repercussions on the resulting audio.
@ -69,10 +69,10 @@ impl WaveInfo { @@ -69,10 +69,10 @@ impl WaveInfo {
///
/// # Errors
///
/// This function will return an error if the [WaveInfo] is currently busy,
/// This function will return an error if the [Wave] is currently busy,
/// with the id to the channel in which it's queued.
pub fn get_buffer_mut(&mut self) -> Result<&mut [u8], NdspError> {
match self.get_status() {
match self.status() {
WaveStatus::Playing | WaveStatus::Queued => {
Err(NdspError::WaveBusy(self.played_on_channel.unwrap()))
}
@ -81,7 +81,7 @@ impl WaveInfo { @@ -81,7 +81,7 @@ impl WaveInfo {
}
/// Return this wave's playback status.
pub fn get_status(&self) -> WaveStatus {
pub fn status(&self) -> WaveStatus {
self.raw_data.status.try_into().unwrap()
}
@ -90,12 +90,12 @@ impl WaveInfo { @@ -90,12 +90,12 @@ impl WaveInfo {
/// # Notes
///
/// This value varies depending on [Self::set_sample_count].
pub fn get_sample_count(&self) -> u32 {
self.raw_data.nsamples
pub fn sample_count(&self) -> usize {
self.raw_data.nsamples as usize
}
/// Get the format of the audio data.
pub fn get_format(&self) -> AudioFormat {
pub fn format(&self) -> AudioFormat {
self.audio_format
}
@ -117,25 +117,22 @@ impl WaveInfo { @@ -117,25 +117,22 @@ impl WaveInfo {
/// # Errors
///
/// This function will return an error if the sample size exceeds the buffer's capacity
/// or if the WaveInfo is currently queued.
pub fn set_sample_count(&mut self, sample_count: u32) -> Result<(), NdspError> {
match self.get_status() {
/// or if the [Wave] is currently queued.
pub fn set_sample_count(&mut self, sample_count: usize) -> Result<(), NdspError> {
match self.status() {
WaveStatus::Playing | WaveStatus::Queued => {
return Err(NdspError::WaveBusy(self.played_on_channel.unwrap()));
}
_ => (),
}
let max_count: usize = self.buffer.len() / (self.audio_format.sample_size() as usize);
let max_count = self.buffer.len() / self.audio_format.size();
if sample_count > max_count as u32 {
return Err(NdspError::SampleCountOutOfBounds(
sample_count,
max_count as u32,
));
if sample_count > max_count {
return Err(NdspError::SampleCountOutOfBounds(sample_count, max_count));
}
self.raw_data.nsamples = sample_count;
self.raw_data.nsamples = sample_count as u32;
Ok(())
}
@ -150,16 +147,16 @@ impl TryFrom<u8> for WaveStatus { @@ -150,16 +147,16 @@ impl TryFrom<u8> for WaveStatus {
1 => Ok(Self::Queued),
2 => Ok(Self::Playing),
3 => Ok(Self::Done),
_ => Err("Invalid WaveInfo Status code"),
_ => Err("Invalid Wave Status code"),
}
}
}
impl Drop for WaveInfo {
impl Drop for Wave {
fn drop(&mut self) {
// This was the only way I found I could check for improper drops of `WaveInfos`.
// This was the only way I found I could check for improper drops of `Wave`.
// A panic was considered, but it would cause issues with drop order against `Ndsp`.
match self.get_status() {
match self.status() {
WaveStatus::Free | WaveStatus::Done => (),
// If the status flag is "unfinished"
_ => {

Loading…
Cancel
Save