github-mirrors/librespot
1
0
Fork 0
mirror of https://github.com/librespot-org/librespot.git synced 2024-12-18 17:11:53 +00:00
Code Issues Projects Releases Packages Wiki Activity

Improve initial loading time

Browse source 
- Configure the decoder according to Spotify's metadata, don't probe

- Return from `AudioFile::open` as soon as possible, with the smallest
  possible block size suitable for opening the decoder, so the UI
  transitions from loading to playing/paused state. From there,
  the regular prefetching will take over.
This commit is contained in:
Roderick van Domburg 2022-01-04 22:57:00 +01:00
parent eabdd79275
commit 3e09eff906
No known key found for this signature in database
GPG key ID: A9EF5222A26F0451
3 changed files with 60 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
audio/src/fetch/mod.rs
View file

@ -65,10 +65,7 @@ pub const MINIMUM_DOWNLOAD_SIZE: usize = 1024 * 128;
/// Note: if the file is opened to play from the beginning, the amount of data to
/// read ahead is requested in addition to this amount. If the file is opened to seek to
/// another position, then only this amount is requested on the first request.
pub const INITIAL_DOWNLOAD_SIZE: usize = 1024 * 128;
/// The ping time that is used for calculations before a ping time was actually measured.
pub const INITIAL_PING_TIME_ESTIMATE: Duration = Duration::from_millis(500);
pub const INITIAL_DOWNLOAD_SIZE: usize = 1024 * 8;
/// If the measured ping time to the Spotify server is larger than this value, it is capped
/// to avoid run-away block sizes and pre-fetching.
@ -321,7 +318,6 @@ impl AudioFile {
session: &Session,
file_id: FileId,
bytes_per_second: usize,
play_from_beginning: bool,
) -> Result<AudioFile, Error> {
if let Some(file) = session.cache().and_then(|cache| cache.file(file_id)) {
debug!("File {} already in cache", file_id);
@ -332,13 +328,8 @@ impl AudioFile {
let (complete_tx, complete_rx) = oneshot::channel();
let streaming = AudioFileStreaming::open(
session.clone(),
file_id,
complete_tx,
bytes_per_second,
play_from_beginning,
);
let streaming =
AudioFileStreaming::open(session.clone(), file_id, complete_tx, bytes_per_second);
let session_ = session.clone();
session.spawn(complete_rx.map_ok(move |mut file| {
@ -386,38 +377,26 @@ impl AudioFileStreaming {
file_id: FileId,
complete_tx: oneshot::Sender<NamedTempFile>,
bytes_per_second: usize,
play_from_beginning: bool,
) -> Result<AudioFileStreaming, Error> {
// When the audio file is really small, this `download_size` may turn out to be
// larger than the audio file we're going to stream later on. This is OK; requesting
// `Content-Range` > `Content-Length` will return the complete file with status code
// 206 Partial Content.
let download_size = if play_from_beginning {
INITIAL_DOWNLOAD_SIZE
+ max(
(READ_AHEAD_DURING_PLAYBACK.as_secs_f32() * bytes_per_second as f32) as usize,
(INITIAL_PING_TIME_ESTIMATE.as_secs_f32()
* READ_AHEAD_DURING_PLAYBACK_ROUNDTRIPS
* bytes_per_second as f32) as usize,
)
} else {
INITIAL_DOWNLOAD_SIZE
};
let cdn_url = CdnUrl::new(file_id).resolve_audio(&session).await?;
if let Ok(url) = cdn_url.try_get_url() {
trace!("Streaming from {}", url);
}
let mut streamer = session
.spclient()
.stream_from_cdn(&cdn_url, 0, download_size)?;
let request_time = Instant::now();
// When the audio file is really small, this `download_size` may turn out to be
// larger than the audio file we're going to stream later on. This is OK; requesting
// `Content-Range` > `Content-Length` will return the complete file with status code
// 206 Partial Content.
let mut streamer =
session
.spclient()
.stream_from_cdn(&cdn_url, 0, INITIAL_DOWNLOAD_SIZE)?;
// Get the first chunk with the headers to get the file size.
// The remainder of that chunk with possibly also a response body is then
// further processed in `audio_file_fetch`.
let request_time = Instant::now();
let response = streamer.next().await.ok_or(AudioFileError::NoData)??;
let header_value = response
@ -425,14 +404,16 @@ impl AudioFileStreaming {
.get(CONTENT_RANGE)
.ok_or(AudioFileError::Header)?;
let str_value = header_value.to_str()?;
let file_size_str = str_value.split('/').last().unwrap_or_default();
let file_size = file_size_str.parse()?;
let hyphen_index = str_value.find('-').unwrap_or_default();
let slash_index = str_value.find('/').unwrap_or_default();
let upper_bound: usize = str_value[hyphen_index + 1..slash_index].parse()?;
let file_size = str_value[slash_index + 1..].parse()?;
let initial_request = StreamingRequest {
streamer,
initial_response: Some(response),
offset: 0,
length: download_size,
length: upper_bound + 1,
request_time,
};

80
playback/src/decoder/symphonia_decoder.rs
View file

@ -1,14 +1,19 @@
use std::io;
use symphonia::core::{
audio::SampleBuffer,
codecs::{Decoder, DecoderOptions},
errors::Error,
formats::{FormatReader, SeekMode, SeekTo},
io::{MediaSource, MediaSourceStream, MediaSourceStreamOptions},
meta::{MetadataOptions, StandardTagKey, Value},
probe::Hint,
units::Time,
use symphonia::{
core::{
audio::SampleBuffer,
codecs::{Decoder, DecoderOptions},
errors::Error,
formats::{FormatReader, SeekMode, SeekTo},
io::{MediaSource, MediaSourceStream, MediaSourceStreamOptions},
meta::{StandardTagKey, Value},
units::Time,
},
default::{
codecs::{Mp3Decoder, VorbisDecoder},
formats::{Mp3Reader, OggReader},
},
};
use super::{AudioDecoder, AudioPacket, DecoderError, DecoderResult};
@ -20,13 +25,13 @@ use crate::{
};
pub struct SymphoniaDecoder {
decoder: Box<dyn Decoder>,
format: Box<dyn FormatReader>,
decoder: Box<dyn Decoder>,
sample_buffer: Option<SampleBuffer<f64>>,
}
impl SymphoniaDecoder {
pub fn new<R>(input: R, format: AudioFileFormat) -> DecoderResult<Self>
pub fn new<R>(input: R, file_format: AudioFileFormat) -> DecoderResult<Self>
where
R: MediaSource + 'static,
{
@ -35,41 +40,37 @@ impl SymphoniaDecoder {
};
let mss = MediaSourceStream::new(Box::new(input), mss_opts);
// Not necessary, but speeds up loading.
let mut hint = Hint::new();
if AudioFiles::is_ogg_vorbis(format) {
hint.with_extension("ogg");
hint.mime_type("audio/ogg");
} else if AudioFiles::is_mp3(format) {
hint.with_extension("mp3");
hint.mime_type("audio/mp3");
} else if AudioFiles::is_flac(format) {
hint.with_extension("flac");
hint.mime_type("audio/flac");
}
let format_opts = Default::default();
let metadata_opts: MetadataOptions = Default::default();
let decoder_opts: DecoderOptions = Default::default();
let probed =
symphonia::default::get_probe().format(&hint, mss, &format_opts, &metadata_opts)?;
let format = probed.format;
let format: Box<dyn FormatReader> = if AudioFiles::is_ogg_vorbis(file_format) {
Box::new(OggReader::try_new(mss, &format_opts)?)
} else if AudioFiles::is_mp3(file_format) {
Box::new(Mp3Reader::try_new(mss, &format_opts)?)
} else {
return Err(DecoderError::SymphoniaDecoder(format!(
"Unsupported format: {:?}",
file_format
)));
};
let track = format.default_track().ok_or_else(|| {
DecoderError::SymphoniaDecoder("Could not retrieve default track".into())
})?;
let decoder = symphonia::default::get_codecs().make(&track.codec_params, &decoder_opts)?;
let decoder_opts: DecoderOptions = Default::default();
let decoder: Box<dyn Decoder> = if AudioFiles::is_ogg_vorbis(file_format) {
Box::new(VorbisDecoder::try_new(&track.codec_params, &decoder_opts)?)
} else if AudioFiles::is_mp3(file_format) {
Box::new(Mp3Decoder::try_new(&track.codec_params, &decoder_opts)?)
} else {
return Err(DecoderError::SymphoniaDecoder(format!(
"Unsupported decoder: {:?}",
file_format
)));
};
let codec_params = decoder.codec_params();
let rate = codec_params.sample_rate.ok_or_else(|| {
let rate = decoder.codec_params().sample_rate.ok_or_else(|| {
DecoderError::SymphoniaDecoder("Could not retrieve sample rate".into())
})?;
let channels = codec_params.channels.ok_or_else(|| {
DecoderError::SymphoniaDecoder("Could not retrieve channel configuration".into())
})?;
if rate != SAMPLE_RATE {
return Err(DecoderError::SymphoniaDecoder(format!(
"Unsupported sample rate: {}",
@ -77,6 +78,9 @@ impl SymphoniaDecoder {
)));
}
let channels = decoder.codec_params().channels.ok_or_else(|| {
DecoderError::SymphoniaDecoder("Could not retrieve channel configuration".into())
})?;
if channels.count() != NUM_CHANNELS as usize {
return Err(DecoderError::SymphoniaDecoder(format!(
"Unsupported number of channels: {}",
@ -85,8 +89,8 @@ impl SymphoniaDecoder {
}
Ok(Self {
decoder,
format,
decoder,
// We set the sample buffer when decoding the first full packet,
// whose duration is also the ideal sample buffer size.

8
playback/src/player.rs
View file

@ -875,17 +875,11 @@ impl PlayerTrackLoader {
};
let bytes_per_second = self.stream_data_rate(format);
let play_from_beginning = position_ms == 0;
// This is only a loop to be able to reload the file if an error occured
// while opening a cached file.
loop {
let encrypted_file = AudioFile::open(
&self.session,
file_id,
bytes_per_second,
play_from_beginning,
);
let encrypted_file = AudioFile::open(&self.session, file_id, bytes_per_second);
let encrypted_file = match encrypted_file.await {
Ok(encrypted_file) => encrypted_file,