use anyhow::{Context, Result};

// use anyhow::{Context, Result};

	errors::Error as SymphoniaError,

	pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {

	pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {

	pub fn from_mss(mss: MediaSourceStream) -> Result<Self> {

	pub fn from_mss(mss: MediaSourceStream) -> Result<Self, anyhow::Error> {

	fn decode_next(&mut self) {

	fn decode_next(&mut self) -> Result<(), SourceError> {

				self.i = 0;

				Ok(())

			Err(e) => {
				self.sample_buf.clear();
				self.buffering = true;
				println!("error while decoding next packed {}", e);
			}

			Err(SymphoniaError::IoError(e)) => match e.kind() {
				std::io::ErrorKind::WouldBlock => {
					self.sample_buf.clear();
					self.buffering = true;
					println!("error while decoding next packed {}", e);
					Err(SourceError::Buffering)
				}
				std::io::ErrorKind::UnexpectedEof => Err(SourceError::EndOfStream),
				_ => Err(SourceError::Buffering),
			},
			_ => Err(SourceError::Buffering),

		self.i = 0;

) -> Result<AudioBufferRef<'a>> {

) -> Result<AudioBufferRef<'a>, SymphoniaError> {

		let packet = format.next_packet().context("Couldn't fetch next packet")?;

		let packet = format.next_packet()?;

	let audio_buf = decoder
		.decode(&packet)
		.context("Couldn't decode next packet")?;

	let audio_buf = decoder.decode(&packet)?;

		self.decode_next();

		self.decode_next()?;

				self.decode_next();
				if self.buffering {
					return Err(SourceError::Buffering);
				}

				self.decode_next()?;

						return;