Struct ModStream

pub struct ModStream { /* private fields */ }

Implementations

impl ModStream

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, Error>

Examples found in repository

examples/play.rs (line 52)

fn play_song(path: &Path) {
    let mut stream = ModStream::from_file(path).unwrap();
    let duration = HrTime {
        seconds: stream.get_duration_seconds(),
    };
    let filename = path.file_name().unwrap().to_string_lossy();
    let title = stream.metadata(Metadata::Title).unwrap();
    let artist = stream.metadata(Metadata::Artist).unwrap();
    let date = stream.metadata(Metadata::Date).unwrap();
    let message = stream.metadata(Metadata::Message).unwrap();
    let tracker = stream.metadata(Metadata::Tracker).unwrap();
    let made_in_string = match (tracker.as_str().is_empty(), date.as_str().is_empty()) {
        (true, true) => String::new(),
        (false, true) => format!("Made in {}\n", tracker),
        (true, false) => format!("Made in {}\n", date),
        (false, false) => format!("Made in {} on {}\n", tracker, date),
    };
    println!(
        "Playing {} {}[{}]\n\
        {}\
        {}",
        title,
        OptStrFmt::new(" by ", artist.as_str(), " "),
        filename,
        made_in_string,
        message
    );
    let mut player = SoundStreamPlayer::new(&mut stream);
    player.play();
    while player.status() == SoundStatus::PLAYING {
        let offset = HrTime {
            seconds: f64::from(player.playing_offset().as_seconds()),
        };
        print!("{}/{}\r", offset, duration);
        let _ = std::io::stdout().flush();
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    // Leave the output of the previous song on the previous line
    println!()
}

pub fn from_memory(data: &[u8]) -> Self

pub fn get_duration_seconds(&self) -> f64

Examples found in repository

examples/play.rs (line 54)

fn play_song(path: &Path) {
    let mut stream = ModStream::from_file(path).unwrap();
    let duration = HrTime {
        seconds: stream.get_duration_seconds(),
    };
    let filename = path.file_name().unwrap().to_string_lossy();
    let title = stream.metadata(Metadata::Title).unwrap();
    let artist = stream.metadata(Metadata::Artist).unwrap();
    let date = stream.metadata(Metadata::Date).unwrap();
    let message = stream.metadata(Metadata::Message).unwrap();
    let tracker = stream.metadata(Metadata::Tracker).unwrap();
    let made_in_string = match (tracker.as_str().is_empty(), date.as_str().is_empty()) {
        (true, true) => String::new(),
        (false, true) => format!("Made in {}\n", tracker),
        (true, false) => format!("Made in {}\n", date),
        (false, false) => format!("Made in {} on {}\n", tracker, date),
    };
    println!(
        "Playing {} {}[{}]\n\
        {}\
        {}",
        title,
        OptStrFmt::new(" by ", artist.as_str(), " "),
        filename,
        made_in_string,
        message
    );
    let mut player = SoundStreamPlayer::new(&mut stream);
    player.play();
    while player.status() == SoundStatus::PLAYING {
        let offset = HrTime {
            seconds: f64::from(player.playing_offset().as_seconds()),
        };
        print!("{}/{}\r", offset, duration);
        let _ = std::io::stdout().flush();
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    // Leave the output of the previous song on the previous line
    println!()
}

pub fn metadata<'a, K: Key<'a>>(&self, key: K) -> Option<OpenMptString>

Examples found in repository

examples/play.rs (line 57)

fn play_song(path: &Path) {
    let mut stream = ModStream::from_file(path).unwrap();
    let duration = HrTime {
        seconds: stream.get_duration_seconds(),
    };
    let filename = path.file_name().unwrap().to_string_lossy();
    let title = stream.metadata(Metadata::Title).unwrap();
    let artist = stream.metadata(Metadata::Artist).unwrap();
    let date = stream.metadata(Metadata::Date).unwrap();
    let message = stream.metadata(Metadata::Message).unwrap();
    let tracker = stream.metadata(Metadata::Tracker).unwrap();
    let made_in_string = match (tracker.as_str().is_empty(), date.as_str().is_empty()) {
        (true, true) => String::new(),
        (false, true) => format!("Made in {}\n", tracker),
        (true, false) => format!("Made in {}\n", date),
        (false, false) => format!("Made in {} on {}\n", tracker, date),
    };
    println!(
        "Playing {} {}[{}]\n\
        {}\
        {}",
        title,
        OptStrFmt::new(" by ", artist.as_str(), " "),
        filename,
        made_in_string,
        message
    );
    let mut player = SoundStreamPlayer::new(&mut stream);
    player.play();
    while player.status() == SoundStatus::PLAYING {
        let offset = HrTime {
            seconds: f64::from(player.playing_offset().as_seconds()),
        };
        print!("{}/{}\r", offset, duration);
        let _ = std::io::stdout().flush();
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    // Leave the output of the previous song on the previous line
    println!()
}

Trait Implementations

impl Drop for ModStream

fn drop(&mut self)

Executes the destructor for this type.

impl SoundStream for ModStream

fn get_data(&mut self) -> (&mut [i16], bool)

Request a new chunk of audio samples from the stream source.

fn seek(&mut self, offset: Time)

Change the current playing position in the stream source.

fn sample_rate(&self) -> u32

Get the stream sample rate of the stream.

fn channel_count(&self) -> u32

Return the number of channels of the stream.