let (cache, pos) = SoundcloudFetcher::spawn(&hls);

			let cache = SoundcloudFetcher::spawn(&hls);

				SoundcloudMediaSource::new(hls.duration(), hls.segments.iter().len(), cache, pos);

				SoundcloudMediaSource::new(hls.duration(), hls.segments.iter().len(), cache);

// The fetcher will try to keep the cache filled for the next 10 seconds

struct SegmentCache(Vec<Option<Vec<u8>>>);

struct SegmentCache {
	source_position: (usize, usize), // (segment idx, byte idx)
	segments: Vec<Option<Vec<u8>>>,
}

	source_pos: Arc<Mutex<Duration>>,

	pub fn spawn(hls: &MediaPlaylist) -> (Arc<Mutex<SegmentCache>>, Arc<Mutex<Duration>>) {
		let segment_cache = Arc::new(Mutex::new(SegmentCache(vec![
			None;
			hls.segments.iter().len()
		])));
		let source_pos = Arc::new(Mutex::new(Duration::ZERO));

	pub fn spawn(hls: &MediaPlaylist) -> Arc<Mutex<SegmentCache>> {
		let segment_cache = Arc::new(Mutex::new(SegmentCache {
			source_position: (0, 0),
			segments: vec![None; hls.segments.iter().len()],
		}));

			source_pos: source_pos.clone(),

		(segment_cache, source_pos)

		segment_cache

	fn time_at_position(&self, segment_idx: usize, byte_idx: usize) -> Duration {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.segment_infos.iter().enumerate() {
			if segment_idx == idx {
				t += Duration::from_secs_f64(byte_idx as f64 / 128_000.0);
				break;
			}
			t += segment.duration;
		}
		return t;
	}

		'outer: loop {
			let curr_time = *self.source_pos.lock();

		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;
			let curr_time = self.time_at_position(source_position.0, source_position.1);

				if self.segment_cache.lock().0[idx].is_none() {

				if self.segment_cache.lock().segments.get(idx) == Some(&None) {

					self.segment_cache.lock().0[idx] = Some(

					self.segment_cache.lock().segments[idx] = Some(

					continue 'outer;

	curr_pos: Duration,

		curr_pos: Arc<Mutex<Duration>>,

			curr_pos: Duration::ZERO,

			self.segment_cache.lock().0[self.curr_segment_idx]

			self.segment_cache.lock().segments[self.curr_segment_idx]

			self.curr_segment = None;

	}
	fn ended(&self) -> bool {
		self.curr_segment_idx >= self.nb_segments

		while nb_filled < buf.len() {

		while nb_filled < buf.len() && !self.ended() {

				let emptied = !self.advance();
				if emptied {
					break;
				}

				self.advance();

		self.segment_cache.lock().source_position = (self.curr_segment_idx, self.curr_offset);