Azorlogh/tunefire - Change CJ3W6DCERC3FVMB7FJOA2V5MTAHHORYOEJB3J5HFJ5PFBVK2UXWQC

seeking fixes & player state sync

Created by 3pZwLy8tqk9sUDM8DL89shmmk6PKLrXyyxzvpu4iA6hQ on July 2, 2022

CJ3W6DCERC3FVMB7FJOA2V5MTAHHORYOEJB3J5HFJ5PFBVK2UXWQC

Dependencies

In channels

main

Change contents

File addition: util (d--x------)
[3.38]

File addition: symphonia.rs (----------)

[0.16]

use std::{fs::File, path::Path, time::Duration};
use anyhow::{Context, Result};
use symphonia::core::{
	audio::{AudioBufferRef, SampleBuffer},
	codecs::Decoder,
	formats::{FormatReader, SeekMode, SeekTo},
	io::MediaSourceStream,
	probe::Hint,
	units::Time,
};
use crate::SourceError;
pub struct Source {
	format: Box<dyn FormatReader>,
	decoder: Box<dyn Decoder>,
	track_id: u32,
	pub duration: Duration,
	pub sample_rate: f64,
	sample_buf: symphonia::core::audio::SampleBuffer<f32>,
	i: u32,
	buffering: bool,
}
impl Source {
	pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
		let file = Box::new(File::open(path).unwrap());
		let mss = MediaSourceStream::new(file, Default::default());
		Self::from_mss(mss)
	}
	pub fn from_mss(mss: MediaSourceStream) -> Result<Self> {
		let mut hint = Hint::new();
		hint.with_extension("mp3");
		// let probed = symphonia::default::get_probe()
		// 	.format(&hint, mss, &Default::default(), &Default::default())
		// 	.unwrap();
		// let mut format = probed.format;
		let mut format = Box::new(symphonia::default::formats::Mp3Reader::try_new(
			mss,
			&Default::default(),
		)?);
		let track = format.default_track().unwrap().clone();
		let mut decoder =
			symphonia::default::get_codecs().make(&track.codec_params, &Default::default())?;
		let codec_params = decoder.codec_params();
		let duration = {
			let time = codec_params
				.time_base
				.unwrap()
				.calc_time(codec_params.n_frames.unwrap());
			Duration::from_secs(time.seconds) + Duration::from_secs_f64(time.frac)
		};
		let audio_buf = get_next_audio_buffer(&mut *format, track.id, &mut *decoder)?;
		let spec = *audio_buf.spec();
		let sample_buf = {
			let duration = audio_buf.capacity() as u64;
			let mut sample_buf = SampleBuffer::new(duration, spec);
			sample_buf.copy_interleaved_ref(audio_buf);
			sample_buf
		};
		Ok(Self {
			format,
			decoder,
			track_id: track.id,
			duration,
			sample_rate: spec.rate as f64,
			sample_buf,
			buffering: false,
			i: 0,
		})
	}
	fn decode_next(&mut self) {
		let next = get_next_audio_buffer(&mut *self.format, self.track_id, &mut *self.decoder);
		match next {
			Ok(audio_buf) => {
				self.sample_buf.copy_interleaved_ref(audio_buf);
				self.buffering = false;
			}
			Err(e) => {
				self.sample_buf.clear();
				self.buffering = true;
				println!("error while decoding next packed {}", e);
			}
		}
		self.i = 0;
	}
}
fn get_next_audio_buffer<'a>(
	format: &mut dyn FormatReader,
	track_id: u32,
	decoder: &'a mut dyn Decoder,
) -> Result<AudioBufferRef<'a>> {
	let packet = loop {
		let packet = format.next_packet().context("Couldn't fetch next packet")?;
		if packet.track_id() == track_id {
			break packet;
		}
	};
	let audio_buf = decoder
		.decode(&packet)
		.context("Couldn't decode next packet")?;
	Ok(audio_buf)
}
impl crate::Source for Source {
	fn seek(&mut self, pos: Duration) -> Result<(), SourceError> {
		if let Err(_) = self.format.seek(
			SeekMode::Coarse,
			SeekTo::Time {
				time: Time {
					seconds: pos.as_secs(),
					frac: pos.as_secs_f64().fract(),
				},
				track_id: None,
			},
		) {
			self.buffering = true;
			return Err(SourceError::Buffering);
		}
		self.decode_next();
		self.i = 0;
		Ok(())
	}
	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), SourceError> {
		for b in buf {
			if self.i >= self.sample_buf.len() as u32 {
				self.decode_next();
				if self.buffering {
					return Err(SourceError::Buffering);
				}
			}
			b[0] = self.sample_buf.samples()[(self.i + 0) as usize];
			b[1] = self.sample_buf.samples()[(self.i + 1) as usize];
			self.i += 2;
		}
		Ok(())
	}
}

File addition: mod.rs (----------)
[0.16]
```
pub mod hls;
pub mod symphonia;
```
File addition: hls (d--x------)
[0.16]

File addition: source.rs (----------)

[0.3761]

use std::{
	io::{Read, Seek, SeekFrom},
	sync::Arc,
	time::Duration,
};
use parking_lot::Mutex;
use tracing::{debug, instrument, trace};
use super::{SegmentCache, SegmentInfos};
use crate::util::hls::BYTERATE;
pub struct MediaSource {
	duration: Duration,
	segment_infos: SegmentInfos,
	segment_cache: Arc<Mutex<SegmentCache>>,
	curr_segment: Option<Vec<u8>>,
	curr_segment_idx: usize,
	curr_offset: usize,
}
impl MediaSource {
	pub fn new(
		duration: Duration,
		segment_infos: SegmentInfos,
		segment_cache: Arc<Mutex<SegmentCache>>,
		pos: Duration,
	) -> Self {
		let (curr_segment_idx, curr_offset) = segment_infos.segment_at(pos).unwrap();
		if segment_cache.lock().segments[curr_segment_idx].is_some() {
			segment_cache.lock().buffering = false;
		}
		segment_cache.lock().source_position = (curr_segment_idx, curr_offset);
		debug!(
			"Creating hls::MediaSource with {:?}/{:?}",
			curr_segment_idx, curr_offset
		);
		Self {
			duration,
			segment_infos,
			segment_cache,
			curr_segment: None,
			curr_segment_idx,
			curr_offset,
		}
	}
	#[instrument(skip_all)]
	fn load_segment(&mut self) -> std::io::Result<()> {
		trace!(
			"grabbing segment {} from the cache...",
			self.curr_segment_idx
		);
		let mut cache = self.segment_cache.lock();
		let segment = match &cache.segments[self.curr_segment_idx] {
			Some(s) => s.clone(),
			None => {
				debug!("failed to grab segment");
				cache.buffering = true;
				return Err(std::io::Error::new(
					std::io::ErrorKind::WouldBlock,
					"Buffering...",
				));
			}
		};
		self.curr_segment = Some(segment);
		Ok(())
	}
	fn advance(&mut self) -> std::io::Result<()> {
		self.curr_segment_idx += 1;
		self.curr_segment = None;
		if self.curr_segment_idx < self.segment_infos.0.len() {
			self.load_segment()?;
			self.curr_offset = 0;
			Ok(())
		} else {
			Err(std::io::Error::new(
				std::io::ErrorKind::UnexpectedEof,
				"End of stream",
			))
		}
	}
	fn ended(&self) -> bool {
		self.curr_segment_idx >= self.segment_infos.0.len()
	}
}
impl Read for MediaSource {
	fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
		if self.curr_segment.is_none() {
			self.load_segment()?;
			// self.curr_offset = 0;
		}
		let mut nb_filled = 0;
		while nb_filled < buf.len() && !self.ended() {
			let segment = self.curr_segment.as_ref().unwrap();
			let nb_remaining_to_take = buf.len() - nb_filled;
			// debug!("{:?} - {:?}", segment.len(), self.curr_offset);
			let nb_available_in_segment = segment.len().saturating_sub(self.curr_offset);
			let nb_to_take = nb_remaining_to_take.min(nb_available_in_segment);
			let segment_slice = &segment[self.curr_offset..][..nb_to_take];
			buf[nb_filled..nb_filled + nb_to_take].copy_from_slice(segment_slice);
			self.curr_offset += nb_to_take;
			nb_filled += nb_to_take;
			if nb_filled < buf.len() {
				self.advance()?;
			}
		}
		self.segment_cache.lock().source_position = (self.curr_segment_idx, self.curr_offset);
		Ok(nb_filled)
	}
}
impl Seek for MediaSource {
	fn seek(&mut self, seek_from: std::io::SeekFrom) -> std::io::Result<u64> {
		let curr_pos = (self
			.segment_infos
			.time_at_position(self.curr_segment_idx, self.curr_offset)
			.as_secs_f64()
			* BYTERATE) as i64;
		let idx = match seek_from {
			SeekFrom::Start(idx) => idx as i64,
			SeekFrom::Current(off) => curr_pos + off,
			SeekFrom::End(off) => (self.duration.as_secs_f64() * BYTERATE) as i64 - off,
		}
		.max(0) as u64;
		let time = Duration::from_secs_f64(idx as f64 / BYTERATE);
		let segment_idx = self
			.segment_infos
			.segment_at(time)
			.map(|p| p.0)
			.unwrap_or(self.segment_infos.0.len() - 1);
		let segment_start = self.segment_infos.time_at_position(segment_idx, 0);
		let offset = ((time - segment_start).as_secs_f64() * BYTERATE) as u64;
		self.curr_segment_idx = segment_idx;
		self.curr_offset = offset as usize;
		self.curr_segment = None;
		self.segment_cache.lock().source_position = (self.curr_segment_idx, self.curr_offset);
		println!(
			"HLS SOURCE SEEKED TO {}/{}",
			self.curr_segment_idx, self.curr_offset
		);
		Ok(idx)
	}
}
impl symphonia::core::io::MediaSource for MediaSource {
	fn is_seekable(&self) -> bool {
		true
	}
	fn byte_len(&self) -> Option<u64> {
		Some((BYTERATE * self.duration.as_secs_f64()).ceil() as u64)
	}
}

File addition: mod.rs (----------)

[0.3761]

use std::time::Duration;
use hls_m3u8::MediaPlaylist;
mod fetcher;
mod source;
pub use fetcher::Fetcher;
pub use source::MediaSource;
pub const BYTERATE: f64 = 128_000.0 / 8.0;
// We need a thread that fetches the HLS segments continuously as we stream the audio
// and inserts them into a cache protected by a mutex.
// And the SoundcloudMediaSource needs to pull the segments from the cache.
// The fetcher will try to keep the cache filled for the next 10 seconds
#[derive(Debug, Clone)]
pub struct SegmentInfo {
	url: String,
	duration: Duration,
}
#[derive(Debug)]
pub struct SegmentCache {
	pub source_position: (usize, usize), // (segment idx, byte idx)
	pub segments: Vec<Option<Vec<u8>>>,
	pub buffering: bool,
}
impl SegmentCache {
	pub fn new(nb_segments: usize) -> Self {
		Self {
			source_position: (0, 0),
			segments: vec![None; nb_segments],
			buffering: false,
		}
	}
}
#[derive(Debug, Clone)]
pub struct SegmentInfos(pub Vec<SegmentInfo>);
impl SegmentInfos {
	pub fn from_hls(hls: &MediaPlaylist) -> Self {
		Self(
			hls.segments
				.values()
				.map(|segment| SegmentInfo {
					url: segment.uri().to_string(),
					duration: segment.duration.duration(),
				})
				.collect(),
		)
	}
	pub fn segment_at(&self, time: Duration) -> Option<(usize, usize)> {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			t += segment.duration;
			if t > time {
				let byte_offset =
					((time - (t - segment.duration)).as_secs_f64() * BYTERATE) as usize;
				return Some((idx, byte_offset));
			}
		}
		return None;
	}
	pub fn time_at_position(&self, segment_idx: usize, byte_idx: usize) -> Duration {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			if segment_idx == idx {
				t += Duration::from_secs_f64(byte_idx as f64 / BYTERATE);
				break;
			}
			t += segment.duration;
		}
		return t;
	}
}

File addition: fetcher.rs (----------)

[0.3761]

use std::{io::Read, sync::Arc, time::Duration};
use anyhow::{Context, Result};
use parking_lot::Mutex;
use tracing::{debug, instrument, trace};
use super::{SegmentCache, SegmentInfos};
#[derive(Debug)]
pub struct Fetcher {
	duration: Duration,
	segment_infos: SegmentInfos,
	segment_cache: Arc<Mutex<SegmentCache>>,
}
impl Fetcher {
	pub fn spawn(
		duration: Duration,
		segment_infos: SegmentInfos,
		segment_cache: Arc<Mutex<SegmentCache>>,
	) -> Result<()> {
		// grab the first segment to help symphonia probe the format
		let first_empty = segment_cache.lock().segments[0].is_none();
		if first_empty {
			segment_cache.lock().segments[0] =
				Some(fetch_segment_retry(&segment_infos.0[0].url, 5)?);
		}
		let fetcher = Fetcher {
			duration,
			segment_infos,
			segment_cache,
		};
		std::thread::spawn(move || {
			if let Err(e) = fetcher.run() {
				println!("{e}");
			}
		});
		Ok(())
	}
	#[instrument(skip_all)]
	fn run(self) -> Result<()> {
		loop {
			// We look where the source is located and make sure the following 10 seconds are loaded in cache
			let source_position = self.segment_cache.lock().source_position;
			trace!("fetching iteration at position {:?}", source_position);
			let curr_time = self
				.segment_infos
				.time_at_position(source_position.0, source_position.1);
			let curr_segment = self
				.segment_infos
				.segment_at(curr_time)
				.map(|p| p.0)
				.unwrap();
			let target_time = (curr_time + Duration::SECOND * 10).min(self.duration);
			let target_segment = self
				.segment_infos
				.segment_at(target_time)
				.map(|p| p.0)
				.unwrap_or(self.segment_infos.0.len());
			for idx in curr_segment..=target_segment {
				if self.segment_cache.lock().segments.get(idx) == Some(&None) {
					trace!("fetching next segment: {}", idx);
					let info = &self.segment_infos.0[idx];
					self.segment_cache.lock().segments[idx] =
						Some(fetch_segment_retry(&info.url, 5)?);
					trace!("next segment received!");
					if idx == self.segment_cache.lock().source_position.0 {
						debug!("STOPPED BUFFERING");
						self.segment_cache.lock().buffering = false;
					}
				}
			}
			std::thread::sleep(Duration::SECOND);
		}
	}
}
fn fetch_segment_retry(url: &str, nb_tries: usize) -> Result<Vec<u8>> {
	for _ in 0..nb_tries {
		if let Ok(s) = fetch_segment(url) {
			return Ok(s);
		}
		std::thread::sleep(Duration::SECOND);
	}
	fetch_segment(url).context("Couldn't fetch segment")
}
fn fetch_segment(url: &str) -> Result<Vec<u8>> {
	Ok(ureq::get(url)
		.call()?
		.into_reader()
		.bytes()
		.collect::<Result<Vec<u8>, std::io::Error>>()?)
}

File addition: source.rs (----------)

[3.83]

use std::{sync::Arc, time::Duration};
use anyhow::Result;
use hls_m3u8::MediaPlaylist;
use parking_lot::Mutex;
use symphonia::core::io::MediaSourceStream;
use crate::{
	util::{
		self,
		hls::{self, SegmentCache, SegmentInfos},
	},
	Source,
};
pub struct SoundcloudSource {
	segment_infos: SegmentInfos,
	cache: Arc<Mutex<SegmentCache>>,
	pub source: util::symphonia::Source,
	seeking: Option<Duration>,
}
impl SoundcloudSource {
	pub fn new(media_playlist: &MediaPlaylist) -> Result<Self> {
		let duration = media_playlist.duration();
		let segment_infos = SegmentInfos::from_hls(&media_playlist);
		let cache = Arc::new(Mutex::new(SegmentCache::new(segment_infos.0.len())));
		hls::Fetcher::spawn(duration, segment_infos.clone(), cache.clone())?;
		let hls_source = hls::MediaSource::new(
			duration,
			segment_infos.clone(),
			cache.clone(),
			Duration::ZERO,
		);
		let mss = MediaSourceStream::new(Box::new(hls_source), Default::default());
		let symphonia_source = util::symphonia::Source::from_mss(mss)?;
		Ok(Self {
			segment_infos,
			cache,
			source: symphonia_source,
			seeking: None,
		})
	}
}
impl Source for SoundcloudSource {
	fn seek(&mut self, pos: Duration) -> Result<(), crate::SourceError> {
		match self.source.seek(pos) {
			Err(crate::SourceError::Buffering) => {
				let (curr_segment_idx, mut curr_offset) =
					self.segment_infos.segment_at(pos).unwrap();
				curr_offset -= 5000; // safety to avoid not having enough data for symphonia
				self.cache.lock().source_position = (curr_segment_idx, curr_offset);
				self.seeking = Some(pos);
				return Err(crate::SourceError::Buffering);
			}
			_ => {}
		}
		Ok(())
	}
	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), crate::SourceError> {
		if let Some(pos) = self.seeking {
			if !self.cache.lock().buffering {
				self.seeking = None;
				let hls_source = hls::MediaSource::new(
					self.source.duration,
					self.segment_infos.clone(),
					self.cache.clone(),
					pos,
				);
				let mss = MediaSourceStream::new(Box::new(hls_source), Default::default());
				self.source = util::symphonia::Source::from_mss(mss).unwrap();
			} else {
				return Err(crate::SourceError::Buffering);
			}
		}
		self.source.next(buf)
	}
}

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 1 [3.116]
B:BD[3.116] → [4.0:45]
```
use std::{convert::TryFrom, time::Duration};
```
[3.116]
[3.216]
```
use std::convert::TryFrom;
```
Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 4 [3.116]
B:BD[3.247] → [2.0:29]
∅:D[2.29] → [4.46:90]
B:BD[3.247] → [4.46:90]
```
use hls_m3u8::MediaPlaylist;
use symphonia::core::io::MediaSourceStream;
```

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 6 [3.116]

B:BD[3.394] → [5.0:62]

use crate::{LocalSource, SongInfo, SongSource, SourcePlugin};

[3.394]

[3.452]

use crate::{SongInfo, SongSource, SourcePlugin};

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 9 [3.116]
B:BD[3.462] → [4.91:104]
```
mod fetcher;
```

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 75 [3.116]

B:BD[3.2158] → [2.30:260]

		let segment_infos = SegmentInfos::from_hls(&hls);
		let cache = fetcher::SoundcloudFetcher::spawn(hls.duration(), segment_infos.clone())?;
		let source = source::SoundcloudMediaSource::new(hls.duration(), segment_infos, cache);

[3.2158]

[3.2215]

		let source = source::SoundcloudSource::new(&hls)?;
		// let mss = MediaSourceStream::new(Box::new(source), Default::default());

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 78 [3.116]

B:BD[3.2401] → [4.1210:1284]

		let mss = MediaSourceStream::new(Box::new(source), Default::default());

[3.2216]

[3.2433]

		// // std::thread::sleep(Duration::SECOND * 2);

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 80 [3.116]

B:BD[3.2434] → [4.1285:1332]

		// std::thread::sleep(Duration::SECOND * 2);

[3.2434]

[6.159]

		// let source = crate::util::symphonia::Source::from_mss(mss).map(|source| SongSource {
		// 	info: SongInfo {
		// 		duration: source.duration,
		// 	},
		// 	sample_rate: source.sample_rate,
		// 	signal: Box::new(source),
		// });

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 88 [3.116]
B:BD[6.160] → [5.121:189]
```
		let source = LocalSource::from_mss(mss).map(|source| SongSource {
```
[6.160]
[4.1397]
```
		Ok(SongSource {
```
Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 90 [3.116]
B:BD[4.1417] → [4.1417:1448]
```
				duration: source.duration,
```
[4.1417]
[4.1448]
```
				duration: source.source.duration,
```
Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 92 [3.116]
B:BD[4.1454] → [4.1454:1490]
```
			sample_rate: source.sample_rate,
```
[4.1454]
[4.1490]
```
			sample_rate: source.source.sample_rate,
```
Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 94 [3.116]
B:BD[4.1519] → [4.1519:1525]
∅:D[7.130] → [3.2478:2479]
∅:D[6.263] → [3.2478:2479]
∅:D[4.1525] → [3.2478:2479]
B:BD[3.2478] → [3.2478:2479]
B:BD[3.2479] → [4.1526:1535]
```
		});
		source
```
[4.1519]
[4.1535]
```
		})
```

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 112 [3.116]

B:BD[3.2790] → [3.2790:2799]

B:BD[3.2799] → [6.311:529]

B:BD[6.529] → [7.131:204]

∅:D[7.204] → [6.529:530]

B:BD[6.529] → [6.529:530]

B:BD[6.530] → [2.261:278]

∅:D[2.278] → [4.1826:1851]

B:BD[6.530] → [4.1826:1851]

∅:D[4.1851] → [6.551:589]

B:BD[6.551] → [6.551:589]

B:BD[6.589] → [4.1852:1878]

∅:D[4.1878] → [7.227:323]

B:BD[7.227] → [7.227:323]

B:BD[7.323] → [2.279:1121]

		}
	}
}
// We need a thread that fetches the HLS segments continuously as we stream the audio
// and inserts them into a cache protected by a mutex.
// And the SoundcloudMediaSource needs to pull the segments from the cache.
// The fetcher will try to keep the cache filled for the next 10 seconds
#[derive(Clone)]
pub struct SegmentInfo {
	url: String,
	duration: Duration,
}
pub struct SegmentCache {
	source_position: (usize, usize), // (segment idx, byte idx)
	segments: Vec<Option<Vec<u8>>>,
}
#[derive(Clone)]
pub struct SegmentInfos(pub Vec<SegmentInfo>);
impl SegmentInfos {
	pub fn from_hls(hls: &MediaPlaylist) -> Self {
		Self(
			hls.segments
				.values()
				.map(|segment| SegmentInfo {
					url: segment.uri().to_string(),
					duration: segment.duration.duration(),
				})
				.collect(),
		)
	}
	fn segment_at(&self, time: Duration) -> Option<usize> {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			t += segment.duration;
			if t > time {
				return Some(idx);
			}
		}
		return None;
	}
	fn time_at_position(&self, segment_idx: usize, byte_idx: usize) -> Duration {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			if segment_idx == idx {
				t += Duration::from_secs_f64(byte_idx as f64 / 128_000.0);
				break;
			}
			t += segment.duration;

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 113 [3.116]
B:BD[2.1125] → [2.1125:1137]
```
		return t;
```
Replacement in tf-player/src/plugins/local.rs at line 1 [3.5500]
B:BD[3.5500] → [3.5501:5551]
B:BD[3.5551] → [2.1143:1174]
∅:D[2.1174] → [3.5606:5687]
B:BD[3.5606] → [3.5606:5687]
B:BD[3.5687] → [2.1175:1219]
∅:D[2.1219] → [3.5711:5749]
B:BD[3.5711] → [3.5711:5749]
B:BD[3.5749] → [2.1220:1234]
∅:D[2.1234] → [3.5749:5752]
B:BD[3.5749] → [3.5749:5752]
```
use std::{fs::File, path::Path, time::Duration};
use anyhow::{Context, Result};
use symphonia::core::{
	audio::{AudioBufferRef, SampleBuffer},
	codecs::Decoder,
	formats::{FormatReader, SeekMode, SeekTo},
	io::MediaSourceStream,
	probe::Hint,
	units::Time,
};
```
[3.5500]
[3.5752]
```
use anyhow::Result;
```

Replacement in tf-player/src/plugins/local.rs at line 4 [3.5500]

B:BD[3.5767] → [2.1235:1313]

use crate::{plugin::SongInfo, SongSource, Source, SourceError, SourcePlugin};

[3.5767]

[3.5820]

use crate::{plugin::SongInfo, SongSource, SourcePlugin};

Replacement in tf-player/src/plugins/local.rs at line 16 [3.5500]

B:BD[3.6063] → [5.388:460]

∅:D[5.460] → [3.6131:6271]

B:BD[3.6131] → [3.6131:6271]

				let source = LocalSource::from_file(path).map(|source| SongSource {
					info: SongInfo {
						duration: source.duration,
					},
					sample_rate: source.sample_rate,
					signal: Box::new(source),
				});

[3.6063]

[3.6271]

				let source =
					crate::util::symphonia::Source::from_file(path).map(|source| SongSource {
						info: SongInfo {
							duration: source.duration,
						},
						sample_rate: source.sample_rate,
						signal: Box::new(source),
					});

Replacement in tf-player/src/plugins/local.rs at line 34 [3.5500]

B:BD[3.6343] → [3.6343:6557]

B:BD[3.6557] → [2.1314:1332]

∅:D[2.1332] → [3.6571:6573]

∅:D[4.1893] → [3.6571:6573]

B:BD[3.6571] → [3.6571:6573]

pub struct LocalSource {
	format: Box<dyn FormatReader>,
	decoder: Box<dyn Decoder>,
	track_id: u32,
	pub duration: Duration,
	pub sample_rate: f64,
	sample_buf: symphonia::core::audio::SampleBuffer<f32>,
	i: u32,
	buffering: bool,
}

[3.6343]

[3.6573]

// pub struct LocalSource {
// 	format: Box<dyn FormatReader>,
// 	decoder: Box<dyn Decoder>,
// 	track_id: u32,
// 	pub duration: Duration,
// 	pub sample_rate: f64,
// 	sample_buf: symphonia::core::audio::SampleBuffer<f32>,
// 	i: u32,
// 	buffering: bool,
// }

Replacement in tf-player/src/plugins/local.rs at line 45 [3.5500]

B:BD[3.6574] → [3.6574:6791]

impl LocalSource {
	pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
		let file = Box::new(File::open(path).unwrap());
		let mss = MediaSourceStream::new(file, Default::default());
		Self::from_mss(mss)
	}

[3.6574]

[3.6791]

// impl LocalSource {
// 	pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
// 		let file = Box::new(File::open(path).unwrap());
// 		let mss = MediaSourceStream::new(file, Default::default());
// 		Self::from_mss(mss)
// 	}

Replacement in tf-player/src/plugins/local.rs at line 52 [3.5500]

B:BD[3.6792] → [3.6792:6877]

	pub fn from_mss(mss: MediaSourceStream) -> Result<Self> {
		let hint = Hint::new();

[3.6792]

[3.6877]

// 	pub fn from_mss(mss: MediaSourceStream) -> Result<Self> {
// 		let hint = Hint::new();

Replacement in tf-player/src/plugins/local.rs at line 55 [3.5500]

B:BD[3.6878] → [3.6878:7004]

		let probed = symphonia::default::get_probe()
			.format(&hint, mss, &Default::default(), &Default::default())
			.unwrap();

[3.6878]

[3.7004]

// 		let probed = symphonia::default::get_probe()
// 			.format(&hint, mss, &Default::default(), &Default::default())
// 			.unwrap();

Replacement in tf-player/src/plugins/local.rs at line 59 [3.5500]
B:BD[3.7005] → [3.7005:7039]
```
		let mut format = probed.format;
```
[3.7005]
[3.7039]
```
// 		let mut format = probed.format;
```

Replacement in tf-player/src/plugins/local.rs at line 61 [3.5500]

B:BD[3.7040] → [3.7040:7095]

		let track = format.default_track().unwrap().clone();

[3.7040]

[3.7095]

// 		let track = format.default_track().unwrap().clone();

Replacement in tf-player/src/plugins/local.rs at line 63 [3.5500]

B:BD[3.7096] → [3.7096:7448]

		let mut decoder =
			symphonia::default::get_codecs().make(&track.codec_params, &Default::default())?;
		let codec_params = decoder.codec_params();
		let duration = {
			let time = codec_params
				.time_base
				.unwrap()
				.calc_time(codec_params.n_frames.unwrap());
			Duration::from_secs(time.seconds) + Duration::from_secs_f64(time.frac)
		};

[3.7096]

[3.7448]

// 		let mut decoder =
// 			symphonia::default::get_codecs().make(&track.codec_params, &Default::default())?;
// 		let codec_params = decoder.codec_params();
// 		let duration = {
// 			let time = codec_params
// 				.time_base
// 				.unwrap()
// 				.calc_time(codec_params.n_frames.unwrap());
// 			Duration::from_secs(time.seconds) + Duration::from_secs_f64(time.frac)
// 		};

Replacement in tf-player/src/plugins/local.rs at line 74 [3.5500]

B:BD[3.7449] → [3.7449:7755]

		let audio_buf = get_next_audio_buffer(&mut *format, track.id, &mut *decoder)?;
		let spec = *audio_buf.spec();
		let sample_buf = {
			let duration = audio_buf.capacity() as u64;
			let mut sample_buf = SampleBuffer::new(duration, spec);
			sample_buf.copy_interleaved_ref(audio_buf);
			sample_buf
		};

[3.7449]

[3.7755]

// 		let audio_buf = get_next_audio_buffer(&mut *format, track.id, &mut *decoder)?;
// 		let spec = *audio_buf.spec();
// 		let sample_buf = {
// 			let duration = audio_buf.capacity() as u64;
// 			let mut sample_buf = SampleBuffer::new(duration, spec);
// 			sample_buf.copy_interleaved_ref(audio_buf);
// 			sample_buf
// 		};

Replacement in tf-player/src/plugins/local.rs at line 83 [3.5500]

B:BD[3.7756] → [3.7756:7876]

B:BD[3.7876] → [2.1333:1354]

∅:D[2.1354] → [3.7893:7910]

∅:D[4.1911] → [3.7893:7910]

B:BD[3.7893] → [3.7893:7910]

		Ok(Self {
			format,
			decoder,
			track_id: track.id,
			duration,
			sample_rate: spec.rate as f64,
			sample_buf,
			buffering: false,
			i: 0,
		})
	}

[3.7756]

[3.7910]

// 		Ok(Self {
// 			format,
// 			decoder,
// 			track_id: track.id,
// 			duration,
// 			sample_rate: spec.rate as f64,
// 			sample_buf,
// 			buffering: false,
// 			i: 0,
// 		})
// 	}

Replacement in tf-player/src/plugins/local.rs at line 95 [3.5500]

B:BD[3.7911] → [3.7911:7940]

∅:D[5.524] → [3.7940:8045]

B:BD[3.7940] → [3.7940:8045]

B:BD[3.8045] → [4.1912:1987]

B:BD[4.1987] → [2.1355:1383]

∅:D[2.1383] → [4.2011:2016]

B:BD[4.2011] → [4.2011:2016]

∅:D[4.2016] → [3.8114:8129]

B:BD[3.8114] → [3.8114:8129]

B:BD[3.8152] → [3.8152:8181]

B:BD[3.8181] → [2.1384:1467]

∅:D[2.1467] → [3.8204:8213]

B:BD[3.8204] → [3.8204:8213]

B:BD[3.8213] → [2.1468:1482]

∅:D[2.1482] → [3.8213:8218]

B:BD[3.8213] → [3.8213:8218]

	fn decode_next(&mut self) {
		let next = get_next_audio_buffer(&mut *self.format, self.track_id, &mut *self.decoder);
		match next {
			Ok(audio_buf) => {
				self.sample_buf.copy_interleaved_ref(audio_buf);
				self.buffering = false;
			}
			Err(e) => {
				self.sample_buf.clear();
				self.buffering = true;
				println!("error while decoding next packed {}", e);
			}
		}
		self.i = 0;
	}
}

[3.7911]

[3.8218]

// 	fn decode_next(&mut self) {
// 		let next = get_next_audio_buffer(&mut *self.format, self.track_id, &mut *self.decoder);
// 		match next {
// 			Ok(audio_buf) => {
// 				self.sample_buf.copy_interleaved_ref(audio_buf);
// 				self.buffering = false;
// 			}
// 			Err(e) => {
// 				self.sample_buf.clear();
// 				self.buffering = true;
// 				println!("error while decoding next packed {}", e);
// 			}
// 		}
// 		self.i = 0;
// 	}
// }

Replacement in tf-player/src/plugins/local.rs at line 112 [3.5500]

B:BD[3.8219] → [3.8219:8383]

B:BD[3.8383] → [2.1483:1559]

∅:D[2.1559] → [3.8421:8483]

B:BD[3.8421] → [3.8421:8483]

B:BD[3.8483] → [2.1560:1648]

∅:D[2.1648] → [3.8526:8543]

B:BD[3.8526] → [3.8526:8543]

fn get_next_audio_buffer<'a>(
	format: &mut dyn FormatReader,
	track_id: u32,
	decoder: &'a mut dyn Decoder,
) -> Result<AudioBufferRef<'a>> {
	let packet = loop {
		let packet = format.next_packet().context("Couldn't fetch next packet")?;
		if packet.track_id() == track_id {
			break packet;
		}
	};
	let audio_buf = decoder
		.decode(&packet)
		.context("Couldn't decode next packet")?;
	Ok(audio_buf)
}

[3.8219]

[3.8652]

// fn get_next_audio_buffer<'a>(
// 	format: &mut dyn FormatReader,
// 	track_id: u32,
// 	decoder: &'a mut dyn Decoder,
// ) -> Result<AudioBufferRef<'a>> {
// 	let packet = loop {
// 		let packet = format.next_packet().context("Couldn't fetch next packet")?;
// 		if packet.track_id() == track_id {
// 			break packet;
// 		}
// 	};
// 	let audio_buf = decoder
// 		.decode(&packet)
// 		.context("Couldn't decode next packet")?;
// 	Ok(audio_buf)
// }

Replacement in tf-player/src/plugins/local.rs at line 129 [3.5500]

B:BD[3.8653] → [5.525:555]

B:BD[5.555] → [2.1649:1910]

∅:D[5.611] → [3.8730:8734]

∅:D[2.1910] → [3.8730:8734]

B:BD[3.8730] → [3.8730:8734]

B:BD[3.8734] → [2.1911:1950]

impl Source for LocalSource {
	fn seek(&mut self, pos: Duration) {
		if let Err(_) = self.format.seek(
			SeekMode::Coarse,
			SeekTo::Time {
				time: Time {
					seconds: pos.as_secs(),
					frac: pos.as_secs_f64().fract(),
				},
				track_id: None,
			},
		) {
			self.buffering = true;
		}
		self.decode_next();
		self.i = 0;
	}

[3.8653]

[2.1950]

// impl Source for LocalSource {
// 	fn seek(&mut self, pos: Duration) {
// 		if let Err(_) = self.format.seek(
// 			SeekMode::Coarse,
// 			SeekTo::Time {
// 				time: Time {
// 					seconds: pos.as_secs(),
// 					frac: pos.as_secs_f64().fract(),
// 				},
// 				track_id: None,
// 			},
// 		) {
// 			self.buffering = true;
// 		}
// 		self.decode_next();
// 		self.i = 0;
// 	}

Replacement in tf-player/src/plugins/local.rs at line 147 [3.5500]

B:BD[2.1951] → [2.1951:2022]

∅:D[2.2022] → [5.612:629]

B:BD[3.8734] → [5.612:629]

B:BD[5.629] → [2.2023:2170]

∅:D[2.2170] → [5.629:765]

B:BD[5.629] → [5.629:765]

∅:D[5.857] → [3.8960:8964]

B:BD[3.8960] → [3.8960:8964]

B:BD[3.8964] → [2.2171:2180]

∅:D[2.2180] → [3.8972:8977]

B:BD[3.8972] → [3.8972:8977]

	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), SourceError> {
		for b in buf {
			if self.i >= self.sample_buf.len() as u32 {
				self.decode_next();
				if self.buffering {
					return Err(SourceError::Buffering);
				}
			}
			b[0] = self.sample_buf.samples()[(self.i + 0) as usize];
			b[1] = self.sample_buf.samples()[(self.i + 1) as usize];
			self.i += 2;
		}
		Ok(())
	}
}

[2.1951]

// 	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), SourceError> {
// 		for b in buf {
// 			if self.i >= self.sample_buf.len() as u32 {
// 				self.decode_next();
// 				if self.buffering {
// 					return Err(SourceError::Buffering);
// 				}
// 			}
// 			b[0] = self.sample_buf.samples()[(self.i + 0) as usize];
// 			b[1] = self.sample_buf.samples()[(self.i + 1) as usize];
// 			self.i += 2;
// 		}
// 		Ok(())
// 	}
// }

Insertion in tf-player/src/plugin.rs at line 20 [3.9012]
[2.2233]
[2.2233]
```
	EndOfStream,
```
Replacement in tf-player/src/plugin.rs at line 24 [3.9012]
B:BD[5.1451] → [2.2237:2273]
```
	fn seek(&mut self, pos: Duration);
```
[5.1451]
[2.2273]
```
	fn seek(&mut self, pos: Duration) -> Result<(), SourceError>;
```
File addition: player (d--x------)
[3.38]

File addition: resampler.rs (----------)

[0.19406]

use anyhow::Result;
use rubato::{InterpolationParameters, Resampler as _, SincFixedOut};
use crate::{SongSource, SourceError};
pub struct Resampler {
	pub resampler: SincFixedOut<f32>,
	pub source_buf: Vec<[f32; 2]>,
	pub in_buf: Vec<Vec<f32>>,
	pub out_buf: Vec<Vec<f32>>,
	pub i: usize,
}
impl Resampler {
	pub fn new(ratio: f64) -> Result<Self> {
		let resampler = SincFixedOut::new(
			ratio,
			2.0,
			InterpolationParameters {
				sinc_len: 256,
				f_cutoff: 0.95,
				oversampling_factor: 128,
				interpolation: rubato::InterpolationType::Linear,
				window: rubato::WindowFunction::Blackman2,
			},
			512,
			2,
		)
		.unwrap();
		Ok(Self {
			source_buf: vec![[0.0; 2]; resampler.input_frames_max()],
			in_buf: resampler.input_buffer_allocate(),
			out_buf: resampler.output_buffer_allocate(),
			resampler,
			i: 0,
		})
	}
	pub fn process(&mut self, source: &mut SongSource) -> Result<(), SourceError> {
		let in_len = self.resampler.input_frames_next();
		source.signal.next(&mut self.source_buf[..in_len])?;
		self.in_buf[0].clear();
		self.in_buf[1].clear();
		for i in 0..in_len {
			self.in_buf[0].push(self.source_buf[i][0]);
			self.in_buf[1].push(self.source_buf[i][1]);
		}
		self.out_buf[0].clear();
		self.out_buf[1].clear();
		self.resampler
			.process_into_buffer(&self.in_buf, &mut self.out_buf, Some(&[true, true]))
			.unwrap();
		self.i = 0;
		Ok(())
	}
}

File addition: mod.rs (----------)

[0.19406]

use std::{
	ops::DerefMut,
	sync::Arc,
	time::{Duration, Instant},
};
use cpal::StreamConfig;
use parking_lot::RwLock;
use crate::{PlayerState, SongSource, SourceError};
mod resampler;
use resampler::Resampler;
pub enum Event {
	Play,
	Pause,
	Stop,
	Seek(Duration),
	SetSource(SongSource),
}
pub struct Player {
	receiver: crossbeam_channel::Receiver<Event>,
	config: StreamConfig,
	pub state: Arc<RwLock<PlayerState>>,
	source: Option<SongSource>,
	resampler: Option<Resampler>,
	buffering_since: Instant,
}
impl Player {
	pub fn new(config: StreamConfig, receiver: crossbeam_channel::Receiver<Event>) -> Self {
		Self {
			receiver,
			config,
			state: Arc::new(RwLock::new(PlayerState::Idle)),
			source: None,
			resampler: None,
			buffering_since: Instant::now(),
		}
	}
	pub fn process_events(&mut self) {
		while let Ok(event) = self.receiver.try_recv() {
			match event {
				Event::Play => {
					self.state.write().play().unwrap();
				}
				Event::Pause => {
					self.state.write().pause().unwrap();
				}
				Event::Stop => {
					*self.state.write() = PlayerState::Idle;
				}
				Event::Seek(position) => {
					self.state.write().seek(position).unwrap();
					match self.source.as_mut().unwrap().signal.seek(position) {
						Err(SourceError::Buffering) => {
							self.buffering_since = Instant::now();
						}
						_ => {}
					}
				}
				Event::SetSource(mut source) => {
					let source_sample_rate = source.sample_rate;
					let mut resampler =
						Resampler::new((self.config.sample_rate.0 as f64) / source_sample_rate)
							.unwrap();
					resampler.process(&mut source).ok();
					self.resampler = Some(resampler);
					self.state.write().set_song(source.info);
					self.source = Some(source);
				}
			}
		}
	}
	pub fn process(&mut self, data: &mut [f32]) {
		self.process_events();
		let playing = match *self.state.read() {
			PlayerState::Playing { paused, .. } => !paused,
			_ => false,
		};
		if !playing {
			for d in data {
				*d = 0.0;
			}
			return;
		}
		let resampler = self.resampler.as_mut().unwrap();
		let source = self.source.as_mut().unwrap();
		if self.buffering_since.elapsed() < Duration::SECOND {
			for d in data {
				*d = 0.0;
			}
			return;
		}
		for d in data.array_chunks_mut::<2>() {
			if resampler.i >= resampler.out_buf[0].len() {
				match resampler.process(source) {
					Err(SourceError::Buffering) => {
						// we should probably zero out the rest of the buffer
						self.buffering_since = Instant::now();
						return;
					}
					Err(SourceError::EndOfStream) => {
						*self.state.write() = PlayerState::Idle;
					}
					Ok(()) => match self.state.write().deref_mut() {
						PlayerState::Playing { offset, .. } => {
							*offset += Duration::from_secs_f64(
								resampler.out_buf[0].len() as f64
									/ self.config.sample_rate.0 as f64,
							);
						}
						_ => {}
					},
				}
			}
			d[0] = resampler.out_buf[0][resampler.i];
			d[1] = resampler.out_buf[1][resampler.i];
			resampler.i += 1;
		}
	}
}

Insertion in tf-player/src/lib.rs at line 5 [3.11625]
[3.11675]
[3.11675]
```
pub mod util;
```
Replacement in tf-player/src/lib.rs at line 7 [3.11625]
B:BD[3.11676] → [3.11676:11712]
```
use std::time::{Duration, Instant};
```
[3.11676]
[3.11712]
```
use std::{sync::Arc, time::Duration};
```
Insertion in tf-player/src/lib.rs at line 11 [3.11625]
[3.11800]
[3.11800]
```
use parking_lot::RwLock;
```
Deletion in tf-player/src/lib.rs at line 26 [3.11625]
B:BD[3.11958] → [3.11958:12010]
```
	Paused {
		song: SongInfo,
		offset: Duration,
	},
```
Replacement in tf-player/src/lib.rs at line 29 [3.11625]
B:BD[3.12059] → [3.12059:12085]
```
		playing_since: Instant,
```
[3.12059]
[3.12085]
```
		paused: bool,
```

Replacement in tf-player/src/lib.rs at line 43 [3.11625]

B:BD[8.339] → [8.339:400]

			Paused { song, .. } | Playing { song, .. } => Some(song),

[8.339]

[8.400]

			Playing { song, .. } => Some(song),

Replacement in tf-player/src/lib.rs at line 50 [3.11625]

B:BD[8.488] → [8.488:555]

			Paused { offset, .. } | Playing { offset, .. } => Some(offset),

[8.488]

[8.555]

			Playing { offset, .. } => Some(offset),

Replacement in tf-player/src/lib.rs at line 56 [3.11625]
B:BD[3.12173] → [3.12173:12192]
```
		*self = Paused {
```
[3.12173]
[3.12192]
```
		*self = Playing {
```
Insertion in tf-player/src/lib.rs at line 59 [3.11625]
[3.12228]
[3.12228]
```
			paused: true,
```

Replacement in tf-player/src/lib.rs at line 65 [3.11625]

B:BD[3.12288] → [3.12288:12425]

			Paused { song, offset } => {
				*self = Playing {
					song: *song,
					offset: *offset,
					playing_since: Instant::now(),
				};

[3.12288]

[3.12425]

			Playing { paused, .. } => {
				*paused = false;

Replacement in tf-player/src/lib.rs at line 75 [3.11625]

B:BD[3.12538] → [3.12538:12573]

B:BD[3.12573] → [3.12573:12592]

B:BD[3.12592] → [3.12592:12602]

B:BD[3.12602] → [3.12602:12718]

			Playing {
				song,
				offset,
				playing_since,
			} => {
				*self = Paused {
					song: *song,
					offset: *offset + Instant::now().duration_since(*playing_since),
				};

[3.12538]

[3.12718]

			Playing { paused, .. } => {
				*paused = true;

Replacement in tf-player/src/lib.rs at line 85 [3.11625]
B:BD[3.12850] → [3.12850:12880]
```
			Paused { offset, .. } => {
```
[3.12850]
[3.12880]
```
			Playing { offset, .. } => {
```

Deletion in tf-player/src/lib.rs at line 89 [3.11625]

B:BD[3.12920] → [3.12920:13058]

			Playing {
				offset,
				playing_since,
				..
			} => {
				*offset = position;
				*playing_since = Instant::now();
				Ok(())
			}

Replacement in tf-player/src/lib.rs at line 96 [3.11625]
B:BD[3.13173] → [3.13173:13196]
```
	stream: cpal::Stream,
```
[3.13173]
[3.13196]
```
	_stream: cpal::Stream,
```
Replacement in tf-player/src/lib.rs at line 98 [3.11625]
B:BD[3.13239] → [3.13239:13260]
```
	state: PlayerState,
```
[3.13239]
[3.13260]
```
	state: Arc<RwLock<PlayerState>>,
```
Insertion in tf-player/src/lib.rs at line 123 [3.11625]
[3.13857]
[3.13857]
```
		let player_state = player.state.clone();
```
Replacement in tf-player/src/lib.rs at line 138 [3.11625]
B:BD[3.14104] → [3.14104:14144]
```
			stream,
			state: PlayerState::Idle,
```
[3.14104]
[3.14144]
```
			_stream: stream,
			state: player_state,
```
Deletion in tf-player/src/lib.rs at line 155 [3.11625]
B:BD[3.14539] → [3.14539:14577]
```
				self.state.set_song(source.info);
```
Replacement in tf-player/src/lib.rs at line 163 [3.11625]
B:BD[3.14755] → [3.14755:14777]
B:BD[3.14777] → [3.14777:14800]
```
		self.state.play()?;
		self.stream.play()?;
```
[3.14755]
[3.14800]
```
		// self.stream.play()?;
```
Replacement in tf-player/src/lib.rs at line 171 [3.11625]
B:BD[3.14935] → [3.14935:14958]
B:BD[3.14958] → [3.14958:14982]
```
		self.state.pause()?;
		self.stream.pause()?;
```
[3.14935]
[3.14982]
```
		// self.stream.pause()?;
```

Replacement in tf-player/src/lib.rs at line 179 [3.11625]

B:BD[3.15124] → [3.15124:15145]

B:BD[3.15145] → [3.15145:15213]

B:BD[3.15213] → [3.15213:15250]

		match self.state {
			Paused { .. } => self.play(),
			Playing { .. } => self.pause(),
			_ => Err(anyhow!("wrong state")),

[3.15124]

[3.15250]

		let paused = match *self.state.read() {
			Playing { paused, .. } => paused,
			_ => return Err(anyhow!("wrong state")),
		};
		if paused {
			self.play()
		} else {
			self.pause()

Deletion in tf-player/src/lib.rs at line 191 [3.11625]
B:BD[3.15318] → [3.15318:15348]
```
		self.state.seek(position)?;
```
Replacement in tf-player/src/lib.rs at line 195 [3.11625]
B:BD[3.15569] → [3.15569:15608]
```
	pub fn state(&self) -> &PlayerState {
```
[3.15413]
[3.15608]
```
	pub fn state(&self) -> &RwLock<PlayerState> {
```
Insertion in tf-player/Cargo.toml at line 28 [3.15663]
[2.2363]
```
tracing = "0.1.35"
```

Replacement in tf-desktop/src/widget/tag_edit.rs at line 2 [3.16467]

B:BD[3.16481] → [3.16481:16592]

	text::ParseFormatter, widget::TextBox, BoxConstraints, Point, Size, UpdateCtx, Widget,
	WidgetExt, WidgetPod,

[3.16481]

[3.16592]

	text::ParseFormatter, widget::TextBox, BoxConstraints, Point, Size, Widget, WidgetExt,
	WidgetPod,

Replacement in tf-desktop/src/widget/tag_edit.rs at line 36 [3.16467]
B:BD[3.17191] → [3.17191:17232]
```
impl Widget<(String, f32)> for TagEdit {
```
[3.17191]
[3.17232]
```
impl Widget<Data> for TagEdit {
```
Replacement in tf-desktop/src/widget/tag_edit.rs at line 41 [3.16467]
B:BD[3.17309] → [3.17309:17337]
```
		data: &mut (String, f32),
```
[3.17309]
[3.17337]
```
		data: &mut Data,
```
Replacement in tf-desktop/src/widget/tag_edit.rs at line 61 [3.16467]
B:BD[3.17803] → [3.17803:17827]
```
		data: &(String, f32),
```
[3.17803]
[3.17827]
```
		data: &Data,
```
Replacement in tf-desktop/src/widget/tag_edit.rs at line 71 [3.16467]
B:BD[3.18013] → [3.18013:18065]
```
		old_data: &(String, f32),
		data: &(String, f32),
```
[3.18013]
[3.18065]
```
		_old_data: &Data,
		data: &Data,
```
Replacement in tf-desktop/src/widget/tag_edit.rs at line 83 [3.16467]
B:BD[3.18261] → [3.18261:18285]
```
		data: &(String, f32),
```
[3.18261]
[3.18285]
```
		data: &Data,
```

Replacement in tf-desktop/src/widget/tag_edit.rs at line 109 [3.16467]

B:BD[3.19054] → [3.19054:19144]

	fn paint(&mut self, ctx: &mut druid::PaintCtx, data: &(String, f32), env: &druid::Env) {

[3.19054]

[3.19144]

	fn paint(&mut self, ctx: &mut druid::PaintCtx, data: &Data, env: &druid::Env) {

File addition: player_tick.rs (----------)

[3.16429]

use std::time::Duration;
use druid::{widget::Controller, Env, Event, EventCtx, TimerToken, Widget};
use crate::command;
#[derive(Default)]
pub struct PlayerTick {
	timer: Option<TimerToken>,
}
impl<T, W: Widget<T>> Controller<T, W> for PlayerTick {
	fn event(&mut self, child: &mut W, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
		match event {
			Event::Timer(t) if Some(*t) == self.timer => {
				ctx.submit_command(command::PLAYER_TICK);
				self.timer = Some(ctx.request_timer(Duration::SECOND));
			}
			Event::Command(c) if c.is(command::SONG_PLAY) => {
				self.timer = Some(ctx.request_timer(Duration::SECOND));
			}
			_ => {}
		}
		if let Event::WindowConnected = event {
			ctx.request_focus();
		}
		child.event(ctx, event, data, env);
	}
}

Replacement in tf-desktop/src/widget/player_bar.rs at line 88 [3.20566]

B:BD[8.1068] → [8.1068:1187]

			PlayerState::Playing { offset, song, .. } | PlayerState::Paused { offset, song } => {
				Some((offset, song))
			}

[8.1068]

[3.23475]

			PlayerState::Playing { offset, song, .. } => Some((offset, song)),

Replacement in tf-desktop/src/widget/knob.rs at line 69 [3.25789]

B:BD[3.27268] → [3.27268:27354]

	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &f32, data: &f32, _env: &Env) {

[3.27268]

[3.27354]

	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &f32, _data: &f32, _env: &Env) {

Replacement in tf-desktop/src/ui/mod.rs at line 1 [3.28167]
B:BD[3.28167] → [8.1503:1553]
```
use std::{cell::RefCell, rc::Rc, time::Duration};
```
[3.28167]
[8.1553]
```
use std::{rc::Rc, time::Duration};
```
Replacement in tf-desktop/src/ui/mod.rs at line 11 [3.28167]
B:BD[3.28411] → [8.1678:1726]
```
use tf_player::{PlayerController, PlayerState};
```
[3.28411]
[3.28411]
```
use tf_player::PlayerState;
```
Replacement in tf-desktop/src/state.rs at line 1 [3.33681]
B:BD[3.33681] → [3.33682:33716]
```
use std::{cell::RefCell, rc::Rc};
```
[3.33681]
[3.33716]
```
use std::rc::Rc;
```
Replacement in tf-desktop/src/state.rs at line 7 [3.33681]
B:BD[3.33808] → [8.2704:2752]
```
use tf_player::{PlayerController, PlayerState};
```
[3.33808]
[3.33841]
```
use tf_player::PlayerState;
```
Deletion in tf-desktop/src/main.rs at line 2 [3.35188]
B:BD[3.35221] → [3.35221:35222]
B:BD[3.35222] → [8.2922:2953]
```
use std::{fmt::Debug, rc::Rc};
```
Replacement in tf-desktop/src/main.rs at line 4 [3.35188]
B:BD[3.35291] → [8.2954:3015]
```
use druid::{im, AppDelegate, AppLauncher, Size, WindowDesc};
```
[3.35291]
[3.35365]
```
use druid::{AppLauncher, WindowDesc};
```
Deletion in tf-desktop/src/main.rs at line 9 [3.35188]
B:BD[3.35422] → [3.35422:35447]
```
use state::SongListItem;
```
Deletion in tf-desktop/src/main.rs at line 10 [3.35188]
∅:D[8.3049] → [3.35469:35499]
B:BD[3.35469] → [3.35469:35499]
```
use url::Url;
use uuid::Uuid;
```
Deletion in tf-desktop/src/main.rs at line 13 [3.35188]
B:BD[3.35517] → [3.35517:35546]
```
use crate::state::SongEdit;
```

Insertion in tf-desktop/src/main.rs at line 18 [3.35188]

[3.35603]

	use tracing_subscriber::prelude::*;
	let filter_layer = tracing_subscriber::filter::LevelFilter::DEBUG;
	let fmt_layer = tracing_subscriber::fmt::layer()
		// Display target (eg "my_crate::some_mod::submod") with logs
		.with_target(true)
		.without_time()
		.with_filter(tracing_subscriber::filter::filter_fn(|metadata| {
			metadata.target().starts_with("tf")
		}));
	tracing_subscriber::registry()
		.with(filter_layer)
		.with(fmt_layer)
		.init();

Deletion in tf-desktop/src/main.rs at line 38 [3.35188]
B:BD[3.35807] → [3.35807:35827]
```
		.log_to_console()
```
Replacement in tf-desktop/src/delegate.rs at line 1 [3.35941]
B:BD[3.35941] → [2.2364:2415]
```
use std::{
	rc::Rc,
	time::{Duration, Instant},
};
```
[3.35941]
[3.35959]
```
use std::{rc::Rc, time::Duration};
```
Replacement in tf-desktop/src/delegate.rs at line 5 [3.35941]
B:BD[3.35984] → [8.3147:3195]
```
use tf_player::{PlayerController, PlayerState};
```
[3.35984]
[3.35984]
```
use tf_player::PlayerController;
```
Replacement in tf-desktop/src/delegate.rs at line 30 [3.35941]
B:BD[3.36178] → [8.3356:3388]
```
		ctx: &mut druid::DelegateCtx,
```
[3.36178]
[3.36211]
```
		_ctx: &mut druid::DelegateCtx,
```

Replacement in tf-desktop/src/delegate.rs at line 41 [3.35941]

B:BD[3.36380] → [3.36380:36437]

		ctx: &mut druid::DelegateCtx,
		target: druid::Target,

[3.36380]

[3.36437]

		_ctx: &mut druid::DelegateCtx,
		_target: druid::Target,

Replacement in tf-desktop/src/delegate.rs at line 45 [3.35941]
B:BD[3.36481] → [3.36481:36501]
```
		env: &druid::Env,
```
[3.36481]
[3.36501]
```
		_env: &druid::Env,
```

Replacement in tf-desktop/src/delegate.rs at line 50 [3.35941]

B:BD[8.3431] → [8.3431:3629]

				let mut ps = self.player.state().clone();
				if let PlayerState::Playing {
					offset,
					playing_since,
					..
				} = &mut ps
				{
					*offset += Instant::now() - *playing_since;
				}

[8.3431]

[8.3629]

				let ps = (*self.player.state().read()).clone();

Replacement in tf-desktop/src/delegate.rs at line 150 [3.35941]
B:BD[3.39443] → [3.39443:39473]
```
					Some((name, value)) => {
```
[3.39443]
[3.39473]
```
					Some((name, _)) => {
```
Replacement in tf-desktop/src/delegate.rs at line 175 [3.35941]
B:BD[3.39914] → [3.39914:39934]
```
		data: &mut State,
```
[3.39914]
[3.39934]
```
		_data: &mut State,
```
Deletion in tf-desktop/src/delegate.rs at line 179 [3.35941]
B:BD[3.39993] → [3.39993:40037]
```
		// data.db.write().conn.close().unwrap();
```

seeking fixes & player state sync

Dependencies

In channels

Change contents

File addition: util (d--x------)

File addition: symphonia.rs (----------)

File addition: mod.rs (----------)

File addition: hls (d--x------)

File addition: source.rs (----------)

File addition: mod.rs (----------)

File addition: fetcher.rs (----------)

File addition: source.rs (----------)

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 1 [3.116]

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 4 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 6 [3.116]

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 9 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 75 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 78 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 80 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 88 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 90 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 92 [3.116]

Replacement in tf-player/src/plugins/soundcloud/mod.rs at line 94 [3.116]

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 112 [3.116]

Deletion in tf-player/src/plugins/soundcloud/mod.rs at line 113 [3.116]

Replacement in tf-player/src/plugins/local.rs at line 1 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 4 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 16 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 34 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 45 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 52 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 55 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 59 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 61 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 63 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 74 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 83 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 95 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 112 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 129 [3.5500]

Replacement in tf-player/src/plugins/local.rs at line 147 [3.5500]

Insertion in tf-player/src/plugin.rs at line 20 [3.9012]

Replacement in tf-player/src/plugin.rs at line 24 [3.9012]

File addition: player (d--x------)

File addition: resampler.rs (----------)

File addition: mod.rs (----------)

Insertion in tf-player/src/lib.rs at line 5 [3.11625]

Replacement in tf-player/src/lib.rs at line 7 [3.11625]

Insertion in tf-player/src/lib.rs at line 11 [3.11625]

Deletion in tf-player/src/lib.rs at line 26 [3.11625]

Replacement in tf-player/src/lib.rs at line 29 [3.11625]

Replacement in tf-player/src/lib.rs at line 43 [3.11625]

Replacement in tf-player/src/lib.rs at line 50 [3.11625]

Replacement in tf-player/src/lib.rs at line 56 [3.11625]

Insertion in tf-player/src/lib.rs at line 59 [3.11625]

Replacement in tf-player/src/lib.rs at line 65 [3.11625]

Replacement in tf-player/src/lib.rs at line 75 [3.11625]

Replacement in tf-player/src/lib.rs at line 85 [3.11625]

Deletion in tf-player/src/lib.rs at line 89 [3.11625]

Replacement in tf-player/src/lib.rs at line 96 [3.11625]

Replacement in tf-player/src/lib.rs at line 98 [3.11625]

Insertion in tf-player/src/lib.rs at line 123 [3.11625]

Replacement in tf-player/src/lib.rs at line 138 [3.11625]

Deletion in tf-player/src/lib.rs at line 155 [3.11625]

Replacement in tf-player/src/lib.rs at line 163 [3.11625]

Replacement in tf-player/src/lib.rs at line 171 [3.11625]

Replacement in tf-player/src/lib.rs at line 179 [3.11625]

Deletion in tf-player/src/lib.rs at line 191 [3.11625]

Replacement in tf-player/src/lib.rs at line 195 [3.11625]

Insertion in tf-player/Cargo.toml at line 28 [3.15663]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 2 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 36 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 41 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 61 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 71 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 83 [3.16467]

Replacement in tf-desktop/src/widget/tag_edit.rs at line 109 [3.16467]

File addition: player_tick.rs (----------)

Replacement in tf-desktop/src/widget/player_bar.rs at line 88 [3.20566]

Replacement in tf-desktop/src/widget/knob.rs at line 69 [3.25789]