thebiblelover7
/
oggify
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added existing file checking and other fixes

master
Adriel Sand 2024-06-16 16:36:32 -07:00
parent f11fb48ce7
commit fe66ff977a
1 changed files with 59 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
src/main.rs 100644 → 100755
View File

@ -21,7 +21,7 @@ use librespot_core::authentication::Credentials;
use librespot_core::config::SessionConfig; use librespot_core::config::SessionConfig;
use librespot_core::session::Session; use librespot_core::session::Session;
use librespot_core::spotify_id::SpotifyId; use librespot_core::spotify_id::SpotifyId;
use librespot_metadata::{Artist, FileFormat, Metadata, Track, Album}; use librespot_metadata::{Artist, FileFormat, Metadata, Track};
use regex::Regex; use regex::Regex;
use scoped_threadpool::Pool; use scoped_threadpool::Pool;
use tokio_core::reactor::Core; use tokio_core::reactor::Core;
@ -55,55 +55,67 @@ fn main() {
.and_then(|capture|SpotifyId::from_base62(&capture[1]).ok()))) .and_then(|capture|SpotifyId::from_base62(&capture[1]).ok())))
.for_each(|id|{ .for_each(|id|{
info!("Getting track {}...", id.to_base62()); info!("Getting track {}...", id.to_base62());
let mut track = core.run(Track::get(&session, id)).expect("Cannot get track metadata"); let fname = format!("{}.ogg", id.to_base62());
if !track.available { let pathexists = std::path::Path::new(&fname).exists();
warn!("Track {} is not available, finding alternative...", id.to_base62()); use std::path::Path;
let alt_track = track.alternatives.iter().find_map(|id|{ if !Path::new(&fname).exists() {
let alt_track = core.run(Track::get(&session, *id)).expect("Cannot get track metadata"); info!("File {} already exists... Skipping...", id.to_base62());
match alt_track.available { } else {
true => Some(alt_track), info!("File does not exist, continuing. Errors {}", Path::new(&fname).exists());
false => None let mut track = core.run(Track::get(&session, id)).expect("Cannot get track metadata");
if !track.available {
warn!("Track {} is not available, finding alternative...", id.to_base62());
let alt_track = track.alternatives.iter().find_map(|id|{
let alt_track = core.run(Track::get(&session, *id)).expect("Cannot get track metadata");
match alt_track.available {
true => Some(alt_track),
false => None
}
});
track = alt_track.expect(&format!("Could not find alternative for track {}", id.to_base62()));
warn!("Found track alternative {} -> {}", id.to_base62(), track.id.to_base62());
}
let artists_strs: Vec<_> = track.artists.iter().map(|id|core.run(Artist::get(&session, *id)).expect("Cannot get artist metadata").name).collect();
debug!("File formats: {}", track.files.keys().map(|filetype|format!("{:?}", filetype)).collect::<Vec<_>>().join(" "));
let file_id = track.files.get(&FileFormat::OGG_VORBIS_160)
.or(track.files.get(&FileFormat::OGG_VORBIS_96))
.or(track.files.get(&FileFormat::OGG_VORBIS_320))
.expect("Could not find a OGG_VORBIS format for the track.");
let key = core.run(session.audio_key().request(track.id, *file_id)).expect("Cannot get audio key");
let mut encrypted_file = core.run(AudioFile::open(&session, *file_id)).unwrap();
let mut buffer = Vec::new();
let mut read_all: Result<usize> = Ok(0);
let fetched = AtomicBool::new(false);
threadpool.scoped(|scope|{
scope.execute(||{
read_all = encrypted_file.read_to_end(&mut buffer);
fetched.store(true, Ordering::Release);
});
while !fetched.load(Ordering::Acquire) {
core.turn(Some(Duration::from_millis(100)));
} }
}); });
track = alt_track.expect(&format!("Could not find alternative for track {}", id.to_base62())); read_all.expect("Cannot read file stream");
warn!("Found track alternative {} -> {}", id.to_base62(), track.id.to_base62()); let mut decrypted_buffer = Vec::new();
} AudioDecrypt::new(key, &buffer[..]).read_to_end(&mut decrypted_buffer).expect("Cannot decrypt stream");
let artists_strs: Vec<_> = track.artists.iter().map(|id|core.run(Artist::get(&session, *id)).expect("Cannot get artist metadata").name).collect(); if args.len() == 3 {
debug!("File formats: {}", track.files.keys().map(|filetype|format!("{:?}", filetype)).collect::<Vec<_>>().join(" ")); let fname = format!("{}.ogg", id.to_base62());
let file_id = track.files.get(&FileFormat::OGG_VORBIS_320) std::fs::write(&fname, &decrypted_buffer[0xa7..]).expect("Cannot write decrypted track");
.or(track.files.get(&FileFormat::OGG_VORBIS_160)) info!("Filename: {}", fname);
.or(track.files.get(&FileFormat::OGG_VORBIS_96)) } else {
.expect("Could not find a OGG_VORBIS format for the track."); // let album = core.run(Album::get(&session, track.album)).expect("Cannot get album metadata");
let key = core.run(session.audio_key().request(track.id, *file_id)).expect("Cannot get audio key"); let fname = format!("{}.ogg", id.to_base62());
let mut encrypted_file = core.run(AudioFile::open(&session, *file_id)).unwrap(); std::fs::write(&fname, &decrypted_buffer[0xa7..]).expect("Cannot write decrypted track");
let mut buffer = Vec::new(); info!("Filename: {}", fname);
let mut read_all: Result<usize> = Ok(0); let mut cmd = Command::new(args[3].to_owned());
let fetched = AtomicBool::new(false); cmd.stdin(Stdio::piped());
threadpool.scoped(|scope|{ cmd.arg(id.to_base62()).arg(track.name).args(artists_strs.iter());
scope.execute(||{ info!("Running Helper");
read_all = encrypted_file.read_to_end(&mut buffer); cmd.spawn().expect("Could not run helper program");
fetched.store(true, Ordering::Release); // let pipe = child.stdin.as_mut().expect("Could not open helper stdin");
}); // pipe.write_all(&decrypted_buffer[0xa7..]).expect("Failed to write to stdin");
while !fetched.load(Ordering::Acquire) { // assert!(child.wait().expect("Out of ideas for error messages").success(), "Helper script returned an error");
core.turn(Some(Duration::from_millis(100)));
} }
});
read_all.expect("Cannot read file stream");
let mut decrypted_buffer = Vec::new();
AudioDecrypt::new(key, &buffer[..]).read_to_end(&mut decrypted_buffer).expect("Cannot decrypt stream");
if args.len() == 3 {
let fname = format!("{} - {}.ogg", artists_strs.join(", "), track.name);
std::fs::write(&fname, &decrypted_buffer[0xa7..]).expect("Cannot write decrypted track");
info!("Filename: {}", fname);
} else {
let album = core.run(Album::get(&session, track.album)).expect("Cannot get album metadata");
let mut cmd = Command::new(args[3].to_owned());
cmd.stdin(Stdio::piped());
cmd.arg(id.to_base62()).arg(track.name).arg(album.name).args(artists_strs.iter());
let mut child = cmd.spawn().expect("Could not run helper program");
let pipe = child.stdin.as_mut().expect("Could not open helper stdin");
pipe.write_all(&decrypted_buffer[0xa7..]).expect("Failed to write to stdin");
assert!(child.wait().expect("Out of ideas for error messages").success(), "Helper script returned an error");
} }
}); });
} }