Dangoware/dango-music-player
1
0
Fork 0
mirror of https://github.com/Dangoware/dango-music-player.git synced 2025-04-19 10:02:53 -05:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #17 from Dangoware/database

Browse source 
Merge database work to main
This commit is contained in:
G2 2023-11-11 16:16:44 -06:00 committed by GitHub
commit 438605875a
13 changed files with 1396 additions and 755 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
Cargo.toml
View file

@ -12,13 +12,12 @@ keywords = ["audio", "music"]
categories = ["multimedia::audio"]
[dependencies]
file-format = { version = "0.17.3", features = ["reader", "serde"] }
lofty = "0.14.0"
rusqlite = { version = "0.29.0", features = ["bundled"] }
serde = { version = "1.0.164", features = ["derive"] }
file-format = { version = "0.22.0", features = ["reader-asf", "reader-ebml", "reader-mp4", "reader-rm", "reader-txt", "reader-xml", "serde"] }
lofty = "0.16.1"
serde = { version = "1.0.191", features = ["derive"] }
time = "0.3.22"
toml = "0.7.5"
walkdir = "2.3.3"
walkdir = "2.4.0"
cpal = "0.15.2"
heapless = "0.7.16"
rb = "0.4.1"
@ -32,3 +31,12 @@ futures = "0.3.28"
rubato = "0.12.0"
arrayvec = "0.7.4"
discord-presence = "0.5.18"
chrono = { version = "0.4.31", features = ["serde"] }
bincode = { version = "2.0.0-rc.3", features = ["serde"] }
unidecode = "0.3.0"
rayon = "1.8.0"
log = "0.4"
pretty_env_logger = "0.4"
base64 = "0.21.5"
snap = "1.1.0"
rcue = "0.1.3"

9
src/lib.rs
View file

@ -5,20 +5,17 @@ pub mod music_tracker {
pub mod music_storage {
pub mod music_db;
pub mod playlist;
}
pub mod music_processor {
pub mod music_processor;
mod utils;
}
pub mod music_player {
pub mod music_player;
pub mod music_output;
pub mod music_player;
pub mod music_resampler;
}
pub mod music_controller {
pub mod music_controller;
pub mod config;
pub mod init;
pub mod music_controller;
}

18
src/music_controller/config.rs
View file

@ -1,10 +1,10 @@
use std::path::PathBuf;
use std::fs::read_to_string;
use std::fs;
use std::fs::read_to_string;
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use crate::music_tracker::music_tracker::{LastFMConfig, DiscordRPCConfig, ListenBrainzConfig};
use crate::music_tracker::music_tracker::{DiscordRPCConfig, LastFMConfig, ListenBrainzConfig};
#[derive(Serialize, Deserialize, PartialEq, Eq)]
pub struct Config {
@ -16,7 +16,7 @@ pub struct Config {
impl Default for Config {
fn default() -> Self {
let path = PathBuf::from("./music_database.db3");
let path = PathBuf::from("./music_database");
return Config {
db_path: Box::new(path),
@ -33,7 +33,7 @@ impl Default for Config {
enabled: false,
api_url: String::from("https://api.listenbrainz.org"),
auth_token: String::from(""),
})
}),
};
}
}
@ -49,8 +49,10 @@ impl Config {
/// Loads config from given file path
pub fn from(config_file: &PathBuf) -> std::result::Result<Config, toml::de::Error> {
return toml::from_str(&read_to_string(config_file)
.expect("Failed to initalize music config: File not found!"));
return toml::from_str(
&read_to_string(config_file)
.expect("Failed to initalize music config: File not found!"),
);
}
/// Saves config to given path
@ -66,7 +68,7 @@ impl Config {
// If configuration file already exists, delete it
match fs::metadata(config_file) {
Ok(_) => fs::remove_file(config_file)?,
Err(_) => {},
Err(_) => {}
}
fs::rename(temp_file, config_file)?;

11
src/music_controller/init.rs
View file

@ -1,9 +1,7 @@
use std::path::Path;
use std::fs::File;
use std::path::Path;
pub fn init() {
}
pub fn init() {}
fn init_config() {
let config_path = "./config.toml";
@ -13,7 +11,4 @@ fn init_config() {
}
}
fn init_db() {
}
fn init_db() {}

47
src/music_controller/music_controller.rs
View file

@ -1,42 +1,51 @@
use std::path::PathBuf;
use std::sync::{RwLock, Arc};
use rusqlite::Result;
use std::sync::{Arc, RwLock};
use crate::music_controller::config::Config;
use crate::music_player::music_player::{MusicPlayer, PlayerStatus, DecoderMessage, DSPMessage};
use crate::music_storage::music_db::Song;
use crate::music_player::music_player::{DecoderMessage, MusicPlayer, PlayerStatus};
use crate::music_storage::music_db::{MusicLibrary, Song, Tag};
pub struct MusicController {
pub config: Arc<RwLock<Config>>,
pub library: MusicLibrary,
music_player: MusicPlayer,
}
impl MusicController {
/// Creates new MusicController with config at given path
pub fn new(config_path: &PathBuf) -> Result<MusicController, std::io::Error>{
pub fn new(config_path: &PathBuf) -> Result<MusicController, Box<dyn std::error::Error>> {
let config = Arc::new(RwLock::new(Config::new(config_path)?));
let music_player = MusicPlayer::new(config.clone());
let library = match MusicLibrary::init(config.clone()) {
Ok(library) => library,
Err(error) => return Err(error),
};
let controller = MusicController {
config,
library,
music_player,
};
return Ok(controller)
return Ok(controller);
}
/// Creates new music controller from a config at given path
pub fn from(config_path: &PathBuf) -> std::result::Result<MusicController, toml::de::Error> {
pub fn from(config_path: &PathBuf) -> Result<MusicController, Box<dyn std::error::Error>> {
let config = Arc::new(RwLock::new(Config::from(config_path)?));
let music_player = MusicPlayer::new(config.clone());
let library = match MusicLibrary::init(config.clone()) {
Ok(library) => library,
Err(error) => return Err(error),
};
let controller = MusicController {
config,
library,
music_player,
};
return Ok(controller)
return Ok(controller);
}
/// Sends given message to control music player
@ -54,15 +63,15 @@ impl MusicController {
return self.music_player.get_current_song();
}
/// Gets audio playback volume
pub fn get_vol(&self) -> f32 {
return self.music_player.music_processor.audio_volume;
/// Queries the [MusicLibrary], returning a `Vec<Song>`
pub fn query_library(
&self,
query_string: &String,
target_tags: Vec<Tag>,
search_location: bool,
sort_by: Vec<Tag>,
) -> Option<Vec<&Song>> {
self.library
.query_tracks(query_string, &target_tags, &sort_by)
}
/// Sets audio playback volume on a scale of 0.0 to 1.0
pub fn set_vol(&mut self, volume: f32) {
self.music_player.music_processor.audio_volume = volume;
self.song_control(DecoderMessage::DSP(DSPMessage::UpdateProcessor(Box::new(self.music_player.music_processor.clone()))));
}
}

111
src/music_player/music_output.rs
View file

@ -1,7 +1,7 @@
use std::{result, thread};
use symphonia::core::audio::{AudioBufferRef, SignalSpec, RawSample, SampleBuffer};
use symphonia::core::conv::{ConvertibleSample, IntoSample, FromSample};
use symphonia::core::audio::{AudioBufferRef, RawSample, SampleBuffer, SignalSpec};
use symphonia::core::conv::{ConvertibleSample, FromSample, IntoSample};
use symphonia::core::units::Duration;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
@ -25,10 +25,21 @@ pub enum AudioOutputError {
pub type Result<T> = result::Result<T, AudioOutputError>;
pub trait OutputSample: SizedSample + FromSample<f32> + IntoSample<f32> +cpal::Sample + ConvertibleSample + RawSample + std::marker::Send + 'static {}
pub trait OutputSample:
SizedSample
+ FromSample<f32>
+ IntoSample<f32>
+ cpal::Sample
+ ConvertibleSample
+ RawSample
+ std::marker::Send
+ 'static
{
}
pub struct AudioOutput<T>
where T: OutputSample,
where
T: OutputSample,
{
ring_buf_producer: rb::Producer<T>,
sample_buf: SampleBuffer<T>,
@ -48,42 +59,63 @@ impl OutputSample for f64 {}
//create a new trait with functions, then impl that somehow
pub fn open_stream(spec: SignalSpec, duration: Duration) -> Result<Box<dyn AudioStream>> {
let host = cpal::default_host();
let host = cpal::default_host();
// Uses default audio device
let device = match host.default_output_device() {
Some(device) => device,
_ => return Err(AudioOutputError::OpenStreamError),
};
// Uses default audio device
let device = match host.default_output_device() {
Some(device) => device,
_ => return Err(AudioOutputError::OpenStreamError),
};
let config = match device.default_output_config() {
Ok(config) => config,
Err(err) => return Err(AudioOutputError::OpenStreamError),
};
let config = match device.default_output_config() {
Ok(config) => config,
Err(err) => return Err(AudioOutputError::OpenStreamError),
};
return match config.sample_format(){
cpal::SampleFormat::I8 => AudioOutput::<i8>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::I16 => AudioOutput::<i16>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::I32 => AudioOutput::<i32>::create_stream(spec, &device, &config.into(), duration),
//cpal::SampleFormat::I64 => AudioOutput::<i64>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::U8 => AudioOutput::<u8>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::U16 => AudioOutput::<u16>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::U32 => AudioOutput::<u32>::create_stream(spec, &device, &config.into(), duration),
//cpal::SampleFormat::U64 => AudioOutput::<u64>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::F32 => AudioOutput::<f32>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::F64 => AudioOutput::<f64>::create_stream(spec, &device, &config.into(), duration),
_ => todo!(),
};
return match config.sample_format() {
cpal::SampleFormat::I8 => {
AudioOutput::<i8>::create_stream(spec, &device, &config.into(), duration)
}
cpal::SampleFormat::I16 => {
AudioOutput::<i16>::create_stream(spec, &device, &config.into(), duration)
}
cpal::SampleFormat::I32 => {
AudioOutput::<i32>::create_stream(spec, &device, &config.into(), duration)
}
//cpal::SampleFormat::I64 => AudioOutput::<i64>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::U8 => {
AudioOutput::<u8>::create_stream(spec, &device, &config.into(), duration)
}
cpal::SampleFormat::U16 => {
AudioOutput::<u16>::create_stream(spec, &device, &config.into(), duration)
}
cpal::SampleFormat::U32 => {
AudioOutput::<u32>::create_stream(spec, &device, &config.into(), duration)
}
//cpal::SampleFormat::U64 => AudioOutput::<u64>::create_stream(spec, &device, &config.into(), duration),
cpal::SampleFormat::F32 => {
AudioOutput::<f32>::create_stream(spec, &device, &config.into(), duration)
}
cpal::SampleFormat::F64 => {
AudioOutput::<f64>::create_stream(spec, &device, &config.into(), duration)
}
_ => todo!(),
};
}
impl<T: OutputSample> AudioOutput<T> {
// Creates the stream (TODO: Merge w/open_stream?)
fn create_stream(spec: SignalSpec, device: &cpal::Device, config: &cpal::StreamConfig, duration: Duration) -> Result<Box<dyn AudioStream>> {
fn create_stream(
spec: SignalSpec,
device: &cpal::Device,
config: &cpal::StreamConfig,
duration: Duration,
) -> Result<Box<dyn AudioStream>> {
let num_channels = config.channels as usize;
// Ring buffer is created with 200ms audio capacity
let ring_len = ((50 * config.sample_rate.0 as usize) / 1000) * num_channels;
let ring_buf= rb::SpscRb::new(ring_len);
let ring_buf = rb::SpscRb::new(ring_len);
let ring_buf_producer = ring_buf.producer();
let ring_buf_consumer = ring_buf.consumer();
@ -95,11 +127,13 @@ impl<T: OutputSample> AudioOutput<T> {
let written = ring_buf_consumer.read(data).unwrap_or(0);
// Mutes non-written samples
data[written..].iter_mut().for_each(|sample| *sample = T::MID);
data[written..]
.iter_mut()
.for_each(|sample| *sample = T::MID);
},
//TODO: Handle error here properly
move |err| println!("Yeah we erroring out here"),
None
None,
);
if let Err(err) = stream_result {
@ -118,10 +152,19 @@ impl<T: OutputSample> AudioOutput<T> {
let mut resampler = None;
if spec.rate != config.sample_rate.0 {
println!("Resampling enabled");
resampler = Some(Resampler::new(spec, config.sample_rate.0 as usize, duration))
resampler = Some(Resampler::new(
spec,
config.sample_rate.0 as usize,
duration,
))
}
Ok(Box::new(AudioOutput { ring_buf_producer, sample_buf, stream, resampler}))
Ok(Box::new(AudioOutput {
ring_buf_producer,
sample_buf,
stream,
resampler,
}))
}
}
@ -154,7 +197,7 @@ impl<T: OutputSample> AudioStream for AudioOutput<T> {
// Flushes resampler if needed
fn flush(&mut self) {
if let Some(resampler) = &mut self.resampler {
let mut stale_samples = resampler.flush().unwrap_or_default();
let mut stale_samples = resampler.flush().unwrap_or_default();
while let Some(written) = self.ring_buf_producer.write_blocking(stale_samples) {
stale_samples = &stale_samples[written..];

203
src/music_player/music_player.rs
View file

@ -1,31 +1,31 @@
use std::sync::mpsc::{self, Sender, Receiver};
use std::io::SeekFrom;
use std::sync::mpsc::{self, Receiver, Sender};
use std::sync::{Arc, RwLock};
use std::thread;
use std::io::SeekFrom;
use async_std::io::ReadExt;
use async_std::task;
use futures::future::join_all;
use symphonia::core::codecs::{CODEC_TYPE_NULL, DecoderOptions, Decoder};
use symphonia::core::codecs::{Decoder, DecoderOptions, CODEC_TYPE_NULL};
use symphonia::core::errors::Error;
use symphonia::core::formats::{FormatOptions, FormatReader, SeekMode, SeekTo};
use symphonia::core::io::{MediaSourceStream, MediaSource};
use symphonia::core::io::{MediaSource, MediaSourceStream};
use symphonia::core::meta::MetadataOptions;
use symphonia::core::probe::Hint;
use symphonia::core::errors::Error;
use symphonia::core::units::{Time, TimeBase};
use futures::AsyncBufRead;
use crate::music_controller::config::Config;
use crate::music_player::music_output::AudioStream;
use crate::music_processor::music_processor::MusicProcessor;
use crate::music_storage::music_db::{URI, Song};
use crate::music_tracker::music_tracker::{MusicTracker, TrackerError, LastFM, DiscordRPC, ListenBrainz};
use crate::music_storage::music_db::{Song, URI};
use crate::music_tracker::music_tracker::{
DiscordRPC, LastFM, ListenBrainz, MusicTracker, TrackerError,
};
// Struct that controls playback of music
pub struct MusicPlayer {
pub music_processor: MusicProcessor,
player_status: PlayerStatus,
music_trackers: Vec<Box<dyn MusicTracker + Send>>,
current_song: Arc<RwLock<Option<Song>>>,
@ -49,18 +49,12 @@ pub enum DecoderMessage {
Pause,
Stop,
SeekTo(u64),
DSP(DSPMessage)
}
#[derive(Clone)]
pub enum TrackerMessage {
Track(Song),
TrackNow(Song)
}
#[derive(Debug, Clone)]
pub enum DSPMessage {
UpdateProcessor(Box<MusicProcessor>)
TrackNow(Song),
}
// Holds a song decoder reader, etc
@ -75,20 +69,22 @@ struct SongHandler {
impl SongHandler {
pub fn new(uri: &URI) -> Result<Self, ()> {
// Opens remote/local source and creates MediaSource for symphonia
let config = RemoteOptions {media_buffer_len: 10000, forward_buffer_len: 10000};
let config = RemoteOptions {
media_buffer_len: 10000,
forward_buffer_len: 10000,
};
let src: Box<dyn MediaSource> = match uri {
URI::Local(path) => {
match std::fs::File::open(path) {
Ok(file) => Box::new(file),
Err(_) => return Err(()),
}
URI::Local(path) => match std::fs::File::open(path) {
Ok(file) => Box::new(file),
Err(_) => return Err(()),
},
URI::Remote(_, location) => {
match RemoteSource::new(location.as_ref(), &config) {
match RemoteSource::new(location.to_str().unwrap(), &config) {
Ok(remote_source) => Box::new(remote_source),
Err(_) => return Err(()),
}
},
}
_ => todo!(),
};
let mss = MediaSourceStream::new(src, Default::default());
@ -97,26 +93,35 @@ impl SongHandler {
let meta_opts: MetadataOptions = Default::default();
let fmt_opts: FormatOptions = Default::default();
let mut hint = Hint::new();
let hint = Hint::new();
let probed = symphonia::default::get_probe().format(&hint, mss, &fmt_opts, &meta_opts).expect("Unsupported format");
let probed = symphonia::default::get_probe()
.format(&hint, mss, &fmt_opts, &meta_opts)
.expect("Unsupported format");
let mut reader = probed.format;
let reader = probed.format;
let track = reader.tracks()
.iter()
.find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
.expect("no supported audio tracks");
let track = reader
.tracks()
.iter()
.find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
.expect("no supported audio tracks");
let time_base = track.codec_params.time_base;
let duration = track.codec_params.n_frames;
let dec_opts: DecoderOptions = Default::default();
let mut decoder = symphonia::default::get_codecs().make(&track.codec_params, &dec_opts)
.expect("unsupported codec");
let decoder = symphonia::default::get_codecs()
.make(&track.codec_params, &dec_opts)
.expect("unsupported codec");
return Ok(SongHandler {reader, decoder, time_base, duration});
return Ok(SongHandler {
reader,
decoder,
time_base,
duration,
});
}
}
@ -127,10 +132,14 @@ impl MusicPlayer {
let (status_sender, status_receiver) = mpsc::channel();
let current_song = Arc::new(RwLock::new(None));
MusicPlayer::start_player(message_receiver, status_sender, config.clone(), current_song.clone());
MusicPlayer::start_player(
message_receiver,
status_sender,
config.clone(),
current_song.clone(),
);
MusicPlayer {
music_processor: MusicProcessor::new(),
music_trackers: Vec::new(),
player_status: PlayerStatus::Stopped,
current_song,
@ -140,14 +149,18 @@ impl MusicPlayer {
}
}
fn start_tracker(status_sender: Sender<Result<(), TrackerError>>, tracker_receiver: Receiver<TrackerMessage>, config: Arc<RwLock<Config>>) {
fn start_tracker(
status_sender: Sender<Result<(), TrackerError>>,
tracker_receiver: Receiver<TrackerMessage>,
config: Arc<RwLock<Config>>,
) {
thread::spawn(move || {
let global_config = &*config.read().unwrap();
// Sets local config for trackers to detect changes
let local_config = global_config.clone();
let mut trackers: Vec<Box<dyn MusicTracker>> = Vec::new();
// Updates local trackers to the music controller config // TODO: refactor
let update_trackers = |trackers: &mut Vec<Box<dyn MusicTracker>>|{
let update_trackers = |trackers: &mut Vec<Box<dyn MusicTracker>>| {
if let Some(lastfm_config) = global_config.lastfm.clone() {
if lastfm_config.enabled {
trackers.push(Box::new(LastFM::new(&lastfm_config)));
@ -176,9 +189,13 @@ impl MusicPlayer {
let mut futures = Vec::new();
for tracker in trackers.iter_mut() {
match message.clone() {
Ok(TrackerMessage::Track(song)) => futures.push(tracker.track_song(song)),
Ok(TrackerMessage::TrackNow(song)) => futures.push(tracker.track_now(song)),
Err(_) => {},
Ok(TrackerMessage::Track(song)) => {
futures.push(tracker.track_song(song))
}
Ok(TrackerMessage::TrackNow(song)) => {
futures.push(tracker.track_now(song))
}
Err(_) => {}
}
}
results = join_all(futures).await;
@ -193,7 +210,12 @@ impl MusicPlayer {
}
// Opens and plays song with given path in separate thread
fn start_player(message_receiver: Receiver<DecoderMessage>, status_sender: Sender<PlayerStatus>, config: Arc<RwLock<Config>>, current_song: Arc<RwLock<Option<Song>>>) {
fn start_player(
message_receiver: Receiver<DecoderMessage>,
status_sender: Sender<PlayerStatus>,
config: Arc<RwLock<Config>>,
current_song: Arc<RwLock<Option<Song>>>,
) {
// Creates thread that audio is decoded in
thread::spawn(move || {
let current_song = current_song;
@ -204,10 +226,14 @@ impl MusicPlayer {
let mut audio_output: Option<Box<dyn AudioStream>> = None;
let mut music_processor = MusicProcessor::new();
let (tracker_sender, tracker_receiver): (Sender<TrackerMessage>, Receiver<TrackerMessage>) = mpsc::channel();
let (tracker_status_sender, tracker_status_receiver): (Sender<Result<(), TrackerError>>, Receiver<Result<(), TrackerError>>) = mpsc::channel();
let (tracker_sender, tracker_receiver): (
Sender<TrackerMessage>,
Receiver<TrackerMessage>,
) = mpsc::channel();
let (tracker_status_sender, tracker_status_receiver): (
Sender<Result<(), TrackerError>>,
Receiver<Result<(), TrackerError>>,
) = mpsc::channel();
MusicPlayer::start_tracker(tracker_status_sender, tracker_receiver, config);
@ -232,7 +258,7 @@ impl MusicPlayer {
// Handles message received from MusicPlayer struct
match message {
Some(DecoderMessage::OpenSong(song)) => {
let song_uri = song.path.clone();
let song_uri = song.location.clone();
match SongHandler::new(&song_uri) {
Ok(new_handler) => {
song_handler = Some(new_handler);
@ -253,26 +279,29 @@ impl MusicPlayer {
status_sender.send(PlayerStatus::Paused).unwrap();
}
Some(DecoderMessage::SeekTo(time)) => seek_time = Some(time),
Some(DecoderMessage::DSP(dsp_message)) => {
match dsp_message {
DSPMessage::UpdateProcessor(new_processor) => music_processor = *new_processor,
}
}
// Exits main decode loop and subsequently ends thread
Some(DecoderMessage::Stop) => {
status_sender.send(PlayerStatus::Stopped).unwrap();
break 'main_decode
break 'main_decode;
}
None => {},
None => {}
}
status_sender.send(PlayerStatus::Error).unwrap();
}
// In theory this check should not need to occur?
if let (Some(song_handler), current_song) = (&mut song_handler, &*current_song.read().unwrap()) {
if let (Some(song_handler), current_song) =
(&mut song_handler, &*current_song.read().unwrap())
{
match seek_time {
Some(time) => {
let seek_to = SeekTo::Time { time: Time::from(time), track_id: Some(0) };
song_handler.reader.seek(SeekMode::Accurate, seek_to).unwrap();
let seek_to = SeekTo::Time {
time: Time::from(time),
track_id: Some(0),
};
song_handler
.reader
.seek(SeekMode::Accurate, seek_to)
.unwrap();
seek_time = None;
}
None => {} //Nothing to do!
@ -291,21 +320,30 @@ impl MusicPlayer {
song_time = time_units.seconds as f64 + time_units.frac;
// Tracks song now if song has just started
if song_time == 0.0 {
tracker_sender.send(TrackerMessage::TrackNow(song.clone())).unwrap();
tracker_sender
.send(TrackerMessage::TrackNow(song.clone()))
.unwrap();
}
if let Some(duration) = song_handler.duration {
let song_duration = time_base.calc_time(duration);
let song_duration_secs = song_duration.seconds as f64 + song_duration.frac;
let song_duration_secs =
song_duration.seconds as f64 + song_duration.frac;
// Tracks song if current time is past half of total song duration or past 4 minutes
if (song_duration_secs / 2.0 < song_time || song_time > 240.0) && !song_tracked {
if (song_duration_secs / 2.0 < song_time || song_time > 240.0)
&& !song_tracked
{
song_tracked = true;
tracker_sender.send(TrackerMessage::Track(song.clone())).unwrap();
tracker_sender
.send(TrackerMessage::Track(song.clone()))
.unwrap();
}
}
}
status_sender.send(PlayerStatus::Playing(song_time)).unwrap();
status_sender
.send(PlayerStatus::Playing(song_time))
.unwrap();
match song_handler.decoder.decode(&packet) {
Ok(decoded) => {
@ -314,31 +352,20 @@ impl MusicPlayer {
let spec = *decoded.spec();
let duration = decoded.capacity() as u64;
audio_output.replace(crate::music_player::music_output::open_stream(spec, duration).unwrap());
audio_output.replace(
crate::music_player::music_output::open_stream(spec, duration)
.unwrap(),
);
}
// Handles audio normally provided there is an audio stream
if let Some(ref mut audio_output) = audio_output {
// Changes buffer of the MusicProcessor if the packet has a differing capacity or spec
if music_processor.audio_buffer.capacity() != decoded.capacity() ||music_processor.audio_buffer.spec() != decoded.spec() {
let spec = *decoded.spec();
let duration = decoded.capacity() as u64;
music_processor.set_buffer(duration, spec);
}
let transformed_audio = music_processor.process(&decoded);
// Writes transformed packet to audio out
audio_output.write(transformed_audio).unwrap()
}
},
}
Err(Error::IoError(_)) => {
// rest in peace packet
continue;
},
}
Err(Error::DecodeError(_)) => {
// may you one day be decoded
continue;
},
}
Err(err) => {
// Unrecoverable, though shouldn't panic here
panic!("{}", err);
@ -356,7 +383,7 @@ impl MusicPlayer {
}
}
pub fn get_current_song(&self) -> Option<Song>{
pub fn get_current_song(&self) -> Option<Song> {
match self.current_song.try_read() {
Ok(song) => return (*song).clone(),
Err(_) => return None,
@ -432,13 +459,13 @@ impl std::io::Read for RemoteSource {
Ok(_) => {
self.media_buffer.extend_from_slice(&buffer);
return Ok(());
},
}
Err(err) => return Err(err),
}
});
match read_bytes {
Err(err) => return Err(err),
_ => {},
_ => {}
}
}
// Reads bytes from the media buffer into the buffer given by
@ -462,13 +489,13 @@ impl std::io::Seek for RemoteSource {
match pos {
// Offset is set to given position
SeekFrom::Start(pos) => {
if pos > self.media_buffer.len() as u64{
if pos > self.media_buffer.len() as u64 {
self.offset = self.media_buffer.len() as u64;
} else {
self.offset = pos;
}
return Ok(self.offset);
},
}
// Offset is set to length of buffer + given position
SeekFrom::End(pos) => {
if self.media_buffer.len() as u64 + pos as u64 > self.media_buffer.len() as u64 {
@ -477,16 +504,16 @@ impl std::io::Seek for RemoteSource {
self.offset = self.media_buffer.len() as u64 + pos as u64;
}
return Ok(self.offset);
},
}
// Offset is set to current offset + given position
SeekFrom::Current(pos) => {
if self.offset + pos as u64 > self.media_buffer.len() as u64{
if self.offset + pos as u64 > self.media_buffer.len() as u64 {
self.offset = self.media_buffer.len() as u64;
} else {
self.offset += pos as u64
}
return Ok(self.offset);
},
}
}
}
}

11
src/music_player/music_resampler.rs
View file

@ -48,7 +48,8 @@ where
// Interleave the planar samples from Rubato.
let num_channels = self.output.len();
self.interleaved.resize(num_channels * self.output[0].len(), T::MID);
self.interleaved
.resize(num_channels * self.output[0].len(), T::MID);
for (i, frame) in self.interleaved.chunks_exact_mut(num_channels).enumerate() {
for (ch, s) in frame.iter_mut().enumerate() {
@ -81,7 +82,13 @@ where
let input = vec![Vec::with_capacity(duration); num_channels];
Self { resampler, input, output, duration, interleaved: Default::default() }
Self {
resampler,
input,
output,
duration,
interleaved: Default::default(),
}
}
/// Resamples a planar/non-interleaved input.

43
src/music_processor/music_processor.rs
View file

@ -1,43 +0,0 @@
use std::fmt::Debug;
use symphonia::core::audio::{AudioBuffer, AudioBufferRef, Signal, AsAudioBufferRef, SignalSpec};
#[derive(Clone)]
pub struct MusicProcessor {
pub audio_buffer: AudioBuffer<f32>,
pub audio_volume: f32,
}
impl Debug for MusicProcessor {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MusicProcessor").field("audio_volume", &self.audio_volume).finish()
}
}
impl MusicProcessor {
/// Returns new MusicProcessor with blank buffer and 100% volume
pub fn new() -> Self {
MusicProcessor {
audio_buffer: AudioBuffer::unused(),
audio_volume: 1.0,
}
}
/// Processes audio samples
///
/// Currently only supports transformations of volume
pub fn process(&mut self, audio_buffer_ref: &AudioBufferRef) -> AudioBufferRef {
audio_buffer_ref.convert(&mut self.audio_buffer);
let process = |sample| sample * self.audio_volume;
self.audio_buffer.transform(process);
return self.audio_buffer.as_audio_buffer_ref();
}
/// Sets buffer of the MusicProcessor
pub fn set_buffer(&mut self, duration: u64, spec: SignalSpec) {
self.audio_buffer = AudioBuffer::new(duration, spec);
}
}

1167
src/music_storage/music_db.rs
View file

File diff suppressed because it is too large Load diff

27
src/music_storage/playlist.rs
View file

@ -1,27 +1,6 @@
use std::path::Path;
use crate::music_controller::config::Config;
use rusqlite::{params, Connection};
use std::path::Path;
pub fn playlist_add(
config: &Config,
playlist_name: &str,
song_paths: &Vec<&Path>
) {
let db_connection = Connection::open(&*config.db_path).unwrap();
for song_path in song_paths {
db_connection.execute(
"INSERT INTO playlists (
playlist_name,
song_path
) VALUES (
?1,
?2
)",
params![
playlist_name,
song_path.to_str().unwrap()
],
).unwrap();
}
pub fn playlist_add(config: &Config, playlist_name: &str, song_paths: &Vec<&Path>) {
unimplemented!()
}

97
src/music_storage/utils.rs Normal file
View file

@ -0,0 +1,97 @@
use std::io::{BufReader, BufWriter};
use std::{error::Error, fs, path::PathBuf};
use walkdir::WalkDir;
use file_format::{FileFormat, Kind};
use snap;
use super::music_db::{Song, AlbumArt, URI};
use unidecode::unidecode;
pub(super) fn normalize(input_string: &String) -> String {
let mut normalized = unidecode(input_string);
// Remove non alphanumeric characters
normalized.retain(|c| c.is_alphanumeric());
normalized
}
pub(super) fn read_library(path: PathBuf) -> Result<Vec<Song>, Box<dyn Error>> {
// Create a new snap reader over the database file
let database = fs::File::open(path)?;
let reader = BufReader::new(database);
let mut d = snap::read::FrameDecoder::new(reader);
// Decode the library from the serialized data into the vec
let library: Vec<Song> = bincode::serde::decode_from_std_read(
&mut d,
bincode::config::standard()
.with_little_endian()
.with_variable_int_encoding(),
)?;
Ok(library)
}
pub(super) fn write_library(
library: &Vec<Song>,
path: PathBuf,
take_backup: bool,
) -> Result<(), Box<dyn Error>> {
// Create 2 new names for the file, a temporary one for writing out, and a backup
let mut writer_name = path.clone();
writer_name.set_extension("tmp");
let mut backup_name = path.clone();
backup_name.set_extension("bkp");
// Create a new BufWriter on the file and make a snap frame encoer for it too
let writer = BufWriter::new(fs::File::create(writer_name.to_path_buf())?);
let mut e = snap::write::FrameEncoder::new(writer);
// Write out the data using bincode
bincode::serde::encode_into_std_write(
&library,
&mut e,
bincode::config::standard()
.with_little_endian()
.with_variable_int_encoding(),
)?;
if path.exists() && take_backup {
fs::rename(&path, backup_name)?;
}
fs::rename(writer_name, &path)?;
Ok(())
}
pub fn find_images(song_path: &PathBuf) -> Result<Vec<AlbumArt>, Box<dyn Error>> {
let mut images: Vec<AlbumArt> = Vec::new();
let song_dir = song_path.parent().ok_or("")?;
for target_file in WalkDir::new(song_dir)
.follow_links(true)
.into_iter()
.filter_map(|e| e.ok())
{
if target_file.depth() >= 3 { // Don't recurse very deep
break
}
let path = target_file.path();
if !path.is_file() {
continue;
}
let format = FileFormat::from_file(&path)?.kind();
if format != Kind::Image {
break
}
let image_uri = URI::Local(path.to_path_buf().canonicalize().unwrap());
images.push(AlbumArt::External(image_uri));
}
Ok(images)
}

139
src/music_tracker/music_tracker.rs
View file

@ -1,14 +1,14 @@
use std::time::{SystemTime, UNIX_EPOCH};
use std::collections::BTreeMap;
use serde_json::json;
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};
use async_trait::async_trait;
use serde::{Serialize, Deserialize};
use md5::{Md5, Digest};
use discord_presence::{Event};
use discord_presence::Event;
use md5::{Digest, Md5};
use serde::{Deserialize, Serialize};
use surf::StatusCode;
use crate::music_storage::music_db::Song;
use crate::music_storage::music_db::{Song, Tag};
#[async_trait]
pub trait MusicTracker {
@ -50,7 +50,7 @@ impl TrackerError {
StatusCode::ServiceUnavailable => TrackerError::ServiceUnavailable,
StatusCode::NotFound => TrackerError::ServiceUnavailable,
_ => TrackerError::Unknown,
}
};
}
}
@ -63,7 +63,7 @@ pub struct LastFMConfig {
}
pub struct LastFM {
config: LastFMConfig
config: LastFMConfig,
}
#[async_trait]
@ -72,12 +72,16 @@ impl MusicTracker for LastFM {
let mut params: BTreeMap<&str, &str> = BTreeMap::new();
// Sets timestamp of song beginning play time
let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Your time is off.").as_secs() - 30;
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("Your time is off.")
.as_secs()
- 30;
let string_timestamp = timestamp.to_string();
let (artist, track) = match (song.artist, song.title) {
let (artist, track) = match (song.get_tag(&Tag::Artist), song.get_tag(&Tag::Title)) {
(Some(artist), Some(track)) => (artist, track),
_ => return Err(TrackerError::InvalidSong)
_ => return Err(TrackerError::InvalidSong),
};
params.insert("method", "track.scrobble");
@ -88,15 +92,15 @@ impl MusicTracker for LastFM {
return match self.api_request(params).await {
Ok(_) => Ok(()),
Err(err) => Err(TrackerError::from_surf_error(err)),
}
};
}
async fn track_now(&mut self, song: Song) -> Result<(), TrackerError> {
let mut params: BTreeMap<&str, &str> = BTreeMap::new();
let (artist, track) = match (song.artist, song.title) {
let (artist, track) = match (song.get_tag(&Tag::Artist), song.get_tag(&Tag::Title)) {
(Some(artist), Some(track)) => (artist, track),
_ => return Err(TrackerError::InvalidSong)
_ => return Err(TrackerError::InvalidSong),
};
params.insert("method", "track.updateNowPlaying");
@ -106,7 +110,7 @@ impl MusicTracker for LastFM {
return match self.api_request(params).await {
Ok(_) => Ok(()),
Err(err) => Err(TrackerError::from_surf_error(err)),
}
};
}
async fn test_tracker(&mut self) -> Result<(), TrackerError> {
@ -116,7 +120,7 @@ impl MusicTracker for LastFM {
return match self.api_request(params).await {
Ok(_) => Ok(()),
Err(err) => Err(TrackerError::from_surf_error(err)),
}
};
}
async fn get_times_tracked(&mut self, song: &Song) -> Result<u32, TrackerError> {
@ -126,7 +130,7 @@ impl MusicTracker for LastFM {
#[derive(Deserialize, Serialize)]
struct AuthToken {
token: String
token: String,
}
#[derive(Deserialize, Serialize, Debug)]
@ -138,27 +142,37 @@ struct SessionResponse {
#[derive(Deserialize, Serialize, Debug)]
struct Session {
session: SessionResponse
session: SessionResponse,
}
impl LastFM {
/// Returns a url to be approved by the user along with the auth token
pub async fn get_auth(api_key: &String) -> Result<String, surf::Error> {
let method = String::from("auth.gettoken");
let api_request_url = format!("http://ws.audioscrobbler.com/2.0/?method={method}&api_key={api_key}&format=json");
let api_request_url = format!(
"http://ws.audioscrobbler.com/2.0/?method={method}&api_key={api_key}&format=json"
);
let auth_token: AuthToken = surf::get(api_request_url).await?.body_json().await?;
let auth_url = format!("http://www.last.fm/api/auth/?api_key={api_key}&token={}", auth_token.token);
let auth_url = format!(
"http://www.last.fm/api/auth/?api_key={api_key}&token={}",
auth_token.token
);
return Ok(auth_url);
}
/// Returns a LastFM session key
pub async fn get_session_key(api_key: &String, shared_secret: &String, auth_token: &String) -> Result<String, surf::Error> {
pub async fn get_session_key(
api_key: &String,
shared_secret: &String,
auth_token: &String,
) -> Result<String, surf::Error> {
let method = String::from("auth.getSession");
// Creates api_sig as defined in last.fm documentation
let api_sig = format!("api_key{api_key}methodauth.getSessiontoken{auth_token}{shared_secret}");
let api_sig =
format!("api_key{api_key}methodauth.getSessiontoken{auth_token}{shared_secret}");
// Creates insecure MD5 hash for last.fm api sig
let mut hasher = Md5::new();
@ -178,13 +192,16 @@ impl LastFM {
/// Creates a new LastFM struct with a given config
pub fn new(config: &LastFMConfig) -> LastFM {
let last_fm = LastFM {
config: config.clone()
config: config.clone(),
};
return last_fm;
}
// Creates an api request with the given parameters
pub async fn api_request(&self, mut params: BTreeMap<&str, &str>) -> Result<surf::Response, surf::Error> {
pub async fn api_request(
&self,
mut params: BTreeMap<&str, &str>,
) -> Result<surf::Response, surf::Error> {
params.insert("api_key", &self.config.dango_api_key);
params.insert("sk", &self.config.session_key);
@ -243,7 +260,7 @@ pub struct DiscordRPCConfig {
pub struct DiscordRPC {
config: DiscordRPCConfig,
pub client: discord_presence::client::Client
pub client: discord_presence::client::Client,
}
impl DiscordRPC {
@ -259,11 +276,20 @@ impl DiscordRPC {
#[async_trait]
impl MusicTracker for DiscordRPC {
async fn track_now(&mut self, song: Song) -> Result<(), TrackerError> {
let unknown = String::from("Unknown");
// Sets song title
let song_name = if let Some(song_name) = song.title {
let song_name = if let Some(song_name) = song.get_tag(&Tag::Title) {
song_name
} else {
String::from("Unknown")
&unknown
};
// Sets album
let album = if let Some(album) = song.get_tag(&Tag::Album) {
album
} else {
&unknown
};
let _client_thread = self.client.start();
@ -274,11 +300,15 @@ impl MusicTracker for DiscordRPC {
return Err(TrackerError::ServiceUnavailable);
}
let start_time = std::time::SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_millis() as u64;
let start_time = std::time::SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64;
// Sets discord account activity to current playing song
let send_activity = self.client.set_activity(|activity| {
activity
.state(format!("Listening to: {}", song_name))
.state(format!("{}", album))
.details(format!("{}", song_name))
.assets(|assets| assets.large_image(&self.config.dango_icon))
.timestamps(|time| time.start(start_time))
});
@ -290,11 +320,11 @@ impl MusicTracker for DiscordRPC {
}
async fn track_song(&mut self, song: Song) -> Result<(), TrackerError> {
return Ok(())
return Ok(());
}
async fn test_tracker(&mut self) -> Result<(), TrackerError> {
return Ok(())
return Ok(());
}
async fn get_times_tracked(&mut self, song: &Song) -> Result<u32, TrackerError> {
@ -316,9 +346,9 @@ pub struct ListenBrainz {
#[async_trait]
impl MusicTracker for ListenBrainz {
async fn track_now(&mut self, song: Song) -> Result<(), TrackerError> {
let (artist, track) = match (song.artist, song.title) {
let (artist, track) = match (song.get_tag(&Tag::Artist), song.get_tag(&Tag::Title)) {
(Some(artist), Some(track)) => (artist, track),
_ => return Err(TrackerError::InvalidSong)
_ => return Err(TrackerError::InvalidSong),
};
// Creates a json to submit a single song as defined in the listenbrainz documentation
let json_req = json!({
@ -333,18 +363,25 @@ impl MusicTracker for ListenBrainz {
]
});
return match self.api_request(&json_req.to_string(), &String::from("/1/submit-listens")).await {
return match self
.api_request(&json_req.to_string(), &String::from("/1/submit-listens"))
.await
{
Ok(_) => Ok(()),
Err(err) => Err(TrackerError::from_surf_error(err))
}
Err(err) => Err(TrackerError::from_surf_error(err)),
};
}
async fn track_song(&mut self, song: Song) -> Result<(), TrackerError> {
let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Your time is off.").as_secs() - 30;
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("Your time is off.")
.as_secs()
- 30;
let (artist, track) = match (song.artist, song.title) {
let (artist, track) = match (song.get_tag(&Tag::Artist), song.get_tag(&Tag::Title)) {
(Some(artist), Some(track)) => (artist, track),
_ => return Err(TrackerError::InvalidSong)
_ => return Err(TrackerError::InvalidSong),
};
let json_req = json!({
@ -360,10 +397,13 @@ impl MusicTracker for ListenBrainz {
]
});
return match self.api_request(&json_req.to_string(), &String::from("/1/submit-listens")).await {
return match self
.api_request(&json_req.to_string(), &String::from("/1/submit-listens"))
.await
{
Ok(_) => Ok(()),
Err(err) => Err(TrackerError::from_surf_error(err))
}
Err(err) => Err(TrackerError::from_surf_error(err)),
};
}
async fn test_tracker(&mut self) -> Result<(), TrackerError> {
todo!()
@ -376,12 +416,19 @@ impl MusicTracker for ListenBrainz {
impl ListenBrainz {
pub fn new(config: &ListenBrainzConfig) -> Self {
ListenBrainz {
config: config.clone()
config: config.clone(),
}
}
// Makes an api request to configured url with given json
pub async fn api_request(&self, request: &String, endpoint: &String) -> Result<surf::Response, surf::Error> {
let reponse = surf::post(format!("{}{}", &self.config.api_url, endpoint)).body_string(request.clone()).header("Authorization", format!("Token {}", self.config.auth_token)).await;
return reponse
pub async fn api_request(
&self,
request: &String,
endpoint: &String,
) -> Result<surf::Response, surf::Error> {
let reponse = surf::post(format!("{}{}", &self.config.api_url, endpoint))
.body_string(request.clone())
.header("Authorization", format!("Token {}", self.config.auth_token))
.await;
return reponse;
}
}