snd/

lib.rs

use std::fmt::Display;

use binrw::{BinRead, BinReaderExt, binread};
use resource_fork::Resource;

#[binread]
#[derive(Debug)]
struct LongArray<T: BinRead + 'static>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    #[br(temp)]
    count: u16,

    #[br(count(count))]
    pub(crate) items: Vec<T>,
}

fn long_list<T: BinRead>(input: LongArray<T>) -> Vec<T>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    input.items
}

#[derive(Debug, Resource)]
#[resource(code = "snd ")]
pub struct Sound {
    pub channels: u16,
    pub sample_rate: SampleRate,
    pub bits_per_sample: u16,
    pub format: AudioFormat,
    pub samples: Vec<i8>,
}

#[derive(Debug, BinRead)]
#[br(repr=u16, big)]
pub enum Format {
    Standard = 1,
    Hypercard = 2,
}

#[derive(Debug, BinRead)]
#[br(repr=u16, big)]
pub enum ModifierType {
    SampledSynth = 5,
}

#[derive(Debug, BinRead)]
#[br(big)]
pub struct Modifier {
    pub modifier_type: ModifierType,
    pub init: i32,
}

#[derive(Debug)]
pub enum Op {
    Null = 0,
    Quiet = 3,
    Flush = 4,
    ReInit = 5,
    Wait = 10,
    Pause = 11,
    Resume = 12,
    CallBack = 13,
    Sync = 14,
    Available = 24,
    Version = 25,
    Volume = 46,              /*sound manager 3.0 or later only*/
    GetVolume = 47,           /*sound manager 3.0 or later only*/
    ClockComponent = 50,      /*sound manager 3.2.1 or later only*/
    GetClockComponent = 51,   /*sound manager 3.2.1 or later only*/
    ScheduledSound = 52,      /*sound manager 3.3 or later only*/
    LinkSoundComponents = 53, /*sound manager 3.3 or later only*/
    Sound = 80,
    Buffer = 81,
    RateMultiplier = 86,
    GetRateMultiplier = 87,
}

#[derive(Debug, thiserror::Error)]
pub enum ConversionError {
    #[error("Unknown opcode {0} encountered")]
    UnknownOpcode(u16),
    #[error("Unknown sample rate {0} encountered")]
    UnknownSampleRate(u32),
    #[error("Unknown format")]
    UnsupportedFormat,
    #[error("Channel count {0} is not supported")]
    UnsupportedChannelCount(u16),
    #[error("Sample format {0} is not supported")]
    UnsupportedSampleFormat(AudioFormat),
    #[error("Header format {0} is not supported yet")]
    UnsupportedHeaderEncoding(HeaderEncoding),
    #[error("Missing functionality")]
    NotImplementedYet,
}

impl TryFrom<u16> for Op {
    type Error = ConversionError;

    fn try_from(value: u16) -> Result<Self, Self::Error> {
        Ok(match value {
            0 => Self::Null,
            3 => Self::Quiet,
            4 => Self::Flush,
            5 => Self::ReInit,
            10 => Self::Wait,
            11 => Self::Pause,
            12 => Self::Resume,
            13 => Self::CallBack,
            14 => Self::Sync,
            24 => Self::Available,
            25 => Self::Version,
            46 => Self::Volume,              /*sound manager 3.0 or later only*/
            47 => Self::GetVolume,           /*sound manager 3.0 or later only*/
            50 => Self::ClockComponent,      /*sound manager 3.2.1 or later only*/
            51 => Self::GetClockComponent,   /*sound manager 3.2.1 or later only*/
            52 => Self::ScheduledSound,      /*sound manager 3.3 or later only*/
            53 => Self::LinkSoundComponents, /*sound manager 3.3 or later only*/
            80 => Self::Sound,
            81 => Self::Buffer,
            86 => Self::RateMultiplier,
            87 => Self::GetRateMultiplier,
            value => return Err(ConversionError::UnknownOpcode(value)),
        })
    }
}

impl From<ConversionError> for binrw::Error {
    fn from(val: ConversionError) -> Self {
        binrw::Error::Custom {
            pos: 0,
            err: Box::new(val),
        }
    }
}

const DATA_OFFSET_FLAG: u16 = 0x8000;
#[derive(Debug)]
pub struct OpCode {
    has_data_offset_flag: bool,
    op: Op,
}

impl BinRead for OpCode {
    type Args<'a> = ();

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        _endian: binrw::Endian,
        _args: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        let data: u16 = reader.read_be()?;
        let has_flag = (data & DATA_OFFSET_FLAG) != 0;
        let cmd = Op::try_from(data & !DATA_OFFSET_FLAG).unwrap();

        Ok(OpCode {
            has_data_offset_flag: has_flag,
            op: cmd,
        })
    }
}

#[derive(Debug, BinRead)]
#[br(big)]
pub struct Command {
    pub opcode: OpCode,
    pub param1: i16,
    pub param2: i32,
}

#[derive(Debug, BinRead)]
#[br(big)]
#[repr(u32)]
pub enum SampleRate {
    ///48000.00000 in fixed-point
    Rate48khz = 0xbb800000,
    ///44100.00000 in fixed-point
    Rate44khz = 0xac440000,
    ///32000.00000 in fixed-point
    Rate32khz = 0x7d000000,
    ///22050.00000 in fixed-point
    Rate22050hz = 0x56220000,
    /// 22254.54545 in fixed-point
    Rate22khz = 0x56ee8ba3,
    /// 16000.00000 in fixed-point
    Rate16khz = 0x3e800000,
    /// 11127.27273 in fixed-point
    Rate11khz = 0x2b7745d1,
    /// 11025.00000 in fixed-point
    Rate11025hz = 0x2b110000,
    /// 8000.00000 in fixed-point
    Rate8khz = 0x1f400000,

    Other(u32),
}

impl TryFrom<SampleRate> for u32 {
    type Error = ConversionError;

    fn try_from(val: SampleRate) -> Result<Self, Self::Error> {
        Ok(match val {
            SampleRate::Rate44khz => 44100,
            SampleRate::Rate48khz => 48000,
            SampleRate::Rate32khz => 32000,
            SampleRate::Rate22050hz => 22050,
            SampleRate::Rate22khz => 22254,
            SampleRate::Rate16khz => 16000,
            SampleRate::Rate11khz => 11127,
            SampleRate::Rate11025hz => 11025,
            SampleRate::Rate8khz => 8000,
            SampleRate::Other(value) => {
                return Err(ConversionError::UnknownSampleRate(value));
            }
        })
    }
}

#[derive(Debug, BinRead)]
#[br(big)]
pub struct Header {
    /// if NIL then samples are in sampleArea
    pub sample_ptr: u32,
    /// length of sound in bytes
    pub length: u32,
    /// sample rate for this sound
    pub sample_rate: SampleRate,
    ///start of looping portion
    pub loop_start: u32,
    ///end of looping portion
    pub loop_end: u32,
    ///header encoding
    pub encoding: HeaderEncoding,
    ///baseFrequency value
    pub base_frequency: u8,
}

#[derive(Debug, BinRead)]
#[br(repr=u8)]
pub enum HeaderEncoding {
    Standard = 0,
    Compressed = 0xFE,
    Extended = 0xFF,
}
impl Display for HeaderEncoding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HeaderEncoding::Standard => f.write_str("Standard"),
            HeaderEncoding::Compressed => f.write_str("Compressed"),
            HeaderEncoding::Extended => f.write_str("Extended"),
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub enum AudioFormat {
    Uncompressed,
    EightBitOffsetBinary,
    SixteenBitBigEndian,
    SixteenBitLittleEndian,
}

impl Display for AudioFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AudioFormat::Uncompressed => f.write_str("Uncompressed"),
            AudioFormat::EightBitOffsetBinary => f.write_str("8bit Offset Binary"),
            AudioFormat::SixteenBitBigEndian => f.write_str("16-bit Big Endian"),
            AudioFormat::SixteenBitLittleEndian => f.write_str("16-bit Little Endian"),
        }
    }
}

impl BinRead for Sound {
    type Args<'a> = ();

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        _endian: binrw::Endian,
        _args: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        match reader.read_be()? {
            Format::Standard => {
                let modifiers: Vec<Modifier> = long_list(reader.read_be()?);
                let commands: Vec<Command> = long_list(reader.read_be()?);
                if modifiers.len() != 1
                    || commands.len() != 1
                    || !commands.first().unwrap().opcode.has_data_offset_flag
                    || !matches!(commands.first().unwrap().opcode.op, Op::Buffer | Op::Sound)
                {
                    return Err(ConversionError::UnsupportedFormat.into());
                }

                let header: Header = reader.read_be().unwrap();
                let (channel_count, packet_count, format) = match header.encoding {
                    HeaderEncoding::Extended => {
                        return Err(
                            ConversionError::UnsupportedHeaderEncoding(header.encoding).into()
                        );
                    }
                    HeaderEncoding::Compressed => {
                        return Err(
                            ConversionError::UnsupportedHeaderEncoding(header.encoding).into()
                        );
                    }
                    HeaderEncoding::Standard => {
                        (1, header.length, AudioFormat::EightBitOffsetBinary)
                    }
                };

                if channel_count != 1 {
                    return Err(ConversionError::UnsupportedChannelCount(channel_count).into());
                }

                if !matches!(format, AudioFormat::EightBitOffsetBinary) {
                    return Err(ConversionError::UnsupportedSampleFormat(format).into());
                }

                let mut samples = Vec::new();
                for _ in 0..packet_count {
                    let sample: i8 = reader.read_be().unwrap();
                    samples.push(sample)
                }

                Ok(Self {
                    format,
                    samples,
                    channels: channel_count,
                    sample_rate: header.sample_rate,
                    bits_per_sample: if matches!(format, AudioFormat::EightBitOffsetBinary) {
                        8
                    } else {
                        16
                    },
                })
            }
            Format::Hypercard => {
                let _ref_count: i16 = reader.read_be()?;
                let commands: Vec<Command> = long_list(reader.read_be()?);
                if commands.len() != 1
                    || !commands.first().unwrap().opcode.has_data_offset_flag
                    || !matches!(commands.first().unwrap().opcode.op, Op::Buffer | Op::Sound)
                {
                    return Err(ConversionError::NotImplementedYet.into());
                }

                let header: Header = reader.read_be().unwrap();
                let (channel_count, packet_count, format) = match header.encoding {
                    HeaderEncoding::Extended => {
                        return Err(ConversionError::NotImplementedYet.into());
                    }
                    HeaderEncoding::Compressed => {
                        return Err(ConversionError::NotImplementedYet.into());
                    }
                    HeaderEncoding::Standard => {
                        (1, header.length, AudioFormat::EightBitOffsetBinary)
                    }
                };

                if channel_count != 1 {
                    return Err(ConversionError::NotImplementedYet.into());
                }

                if !matches!(format, AudioFormat::EightBitOffsetBinary) {
                    return Err(ConversionError::NotImplementedYet.into());
                }

                let mut samples = Vec::new();
                for _ in 0..packet_count {
                    let sample: i8 = reader.read_be().unwrap();
                    samples.push(sample)
                }

                Ok(Self {
                    format,
                    samples,
                    channels: channel_count,
                    sample_rate: header.sample_rate,
                    bits_per_sample: if matches!(format, AudioFormat::EightBitOffsetBinary) {
                        8
                    } else {
                        16
                    },
                })
            }
        }
    }
}