Tidy handling of certain BadArg errors

Additionally, expose ErrorCode::description publically and use it
on-demand rather than retrieving it in advance in Error::from_code.

src/lib.rs

@@ -97,6 +97,13 @@ impl Bandwidth {
 			_ => return None,
 		})
 	}
+
+	fn decode(value: i32, what: &'static str) -> Result<Bandwidth> {
+		match Bandwidth::from_int(value) {
+			Some(bandwidth) => Ok(bandwidth),
+			None => Err(Error::bad_arg(what)),
+		}
+	}
 }
 
 /// Possible error codes.
@@ -120,6 +127,28 @@ pub enum ErrorCode {
 	Unknown = -8,
 }
 
+impl ErrorCode {
+	fn from_int(value: c_int) -> ErrorCode {
+		use ErrorCode::*;
+		match value {
+			ffi::OPUS_BAD_ARG => BadArg,
+			ffi::OPUS_BUFFER_TOO_SMALL => BufferTooSmall,
+			ffi::OPUS_INTERNAL_ERROR => InternalError,
+			ffi::OPUS_INVALID_PACKET => InvalidPacket,
+			ffi::OPUS_UNIMPLEMENTED => Unimplemented,
+			ffi::OPUS_INVALID_STATE => InvalidState,
+			ffi::OPUS_ALLOC_FAIL => AllocFail,
+			_ => Unknown,
+		}
+	}
+
+	/// Get a human-readable error string for this error code.
+	pub fn description(self) -> &'static str {
+		// should always be ASCII and non-null for any input
+		unsafe { CStr::from_ptr(ffi::opus_strerror(self as c_int)) }.to_str().unwrap()
+	}
+}
+
 /// Possible bitrates.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Bitrate {
@@ -132,6 +161,10 @@ pub enum Bitrate {
 }
 
 /// Get the libopus version string.
+///
+/// Applications may look for the substring "-fixed" in the version string to
+/// determine whether they have a fixed-point or floating-point build at
+/// runtime.
 pub fn version() -> &'static str {
 	// verison string should always be ASCII
 	unsafe { CStr::from_ptr(ffi::opus_get_version_string()) }.to_str().unwrap()
@@ -233,8 +266,7 @@ impl Encoder {
 	pub fn get_bandwidth(&mut self) -> Result<Bandwidth> {
 		let mut value: i32 = 0;
 		enc_ctl!(self, OPUS_GET_BANDWIDTH, &mut value);
-		Bandwidth::from_int(value).ok_or_else(||
+		Bandwidth::decode(value, "opus_encoder_ctl(OPUS_GET_BANDWIDTH)")
-			Error::from_code("opus_encoder_ctl(OPUS_GET_BANDWIDTH)", ffi::OPUS_BAD_ARG))
 	}
 
 	/// Get the samping rate the encoder was intialized with.
@@ -390,8 +422,7 @@ impl Decoder {
 	pub fn get_bandwidth(&mut self) -> Result<Bandwidth> {
 		let mut value: i32 = 0;
 		dec_ctl!(self, OPUS_GET_BANDWIDTH, &mut value);
-		Bandwidth::from_int(value).ok_or_else(||
+		Bandwidth::decode(value, "opus_decoder_ctl(OPUS_GET_BANDWIDTH)")
-			Error::from_code("opus_decoder_ctl(OPUS_GET_BANDWIDTH)", ffi::OPUS_BAD_ARG))
 	}
 
 	/// Get the samping rate the decoder was intialized with.
@@ -464,24 +495,24 @@ pub mod packet {
 	/// Get the bandwidth of an Opus packet.
 	pub fn get_bandwidth(packet: &[u8]) -> Result<Bandwidth> {
 		if packet.len() < 1 {
-			return Err(Error::from_code("opus_packet_get_bandwidth", ffi::OPUS_BAD_ARG))
+			return Err(Error::bad_arg("opus_packet_get_bandwidth"));
 		}
 		let bandwidth = unsafe { ffi::opus_packet_get_bandwidth(packet.as_ptr()) };
 		try!(check("opus_packet_get_bandwidth", bandwidth));
-		Bandwidth::from_int(bandwidth).ok_or_else(|| Error::from_code("opus_packet_get_bandwidth", ffi::OPUS_BAD_ARG))
+		Bandwidth::decode(bandwidth, "opus_packet_get_bandwidth")
 	}
 
 	/// Get the number of channels from an Opus packet.
 	pub fn get_nb_channels(packet: &[u8]) -> Result<Channels> {
 		if packet.len() < 1 {
-			return Err(Error::from_code("opus_packet_get_nb_channels", ffi::OPUS_BAD_ARG))
+			return Err(Error::bad_arg("opus_packet_get_nb_channels"));
 		}
 		let channels = unsafe { ffi::opus_packet_get_nb_channels(packet.as_ptr()) };
 		try!(check("opus_packet_get_nb_channels", channels));
 		match channels {
 			1 => Ok(Channels::Mono),
 			2 => Ok(Channels::Stereo),
-			_ => Err(Error::from_code("opus_packet_get_nb_channels", ffi::OPUS_BAD_ARG)),
+			_ => Err(Error::bad_arg("opus_packet_get_nb_channels")),
 		}
 	}
 
@@ -504,7 +535,7 @@ pub mod packet {
 	/// Get the number of samples per frame from an Opus packet.
 	pub fn get_samples_per_frame(packet: &[u8], sample_rate: u32) -> Result<usize> {
 		if packet.len() < 1 {
-			return Err(Error::from_code("opus_packet_get_samples_per_frame", ffi::OPUS_BAD_ARG))
+			return Err(Error::bad_arg("opus_packet_get_samples_per_frame"))
 		}
 		let samples = unsafe { ffi::opus_packet_get_samples_per_frame(packet.as_ptr(), sample_rate as c_int) };
 		try!(check("opus_packet_get_samples_per_frame", samples));
@@ -700,44 +731,40 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[derive(Debug)]
 pub struct Error {
 	function: &'static str,
-	description: &'static str,
 	code: ErrorCode,
 }
 
 impl Error {
+	fn bad_arg(what: &'static str) -> Error {
+		Error { function: what, code: ErrorCode::BadArg }
+	}
+
 	fn from_code(what: &'static str, code: c_int) -> Error {
-		// description should always be ASCII
+		Error { function: what, code: ErrorCode::from_int(code) }
-		let description = unsafe { CStr::from_ptr(ffi::opus_strerror(code)) }.to_str().unwrap();
-		let code = match code {
-			-1 => ErrorCode::BadArg,
-			-2 => ErrorCode::BufferTooSmall,
-			-3 => ErrorCode::InternalError,
-			-4 => ErrorCode::InvalidPacket,
-			-5 => ErrorCode::Unimplemented,
-			-6 => ErrorCode::InvalidState,
-			-7 => ErrorCode::AllocFail,
-			_ => ErrorCode::Unknown,
-		};
-		Error { function: what, description: description, code: code }
 	}
 
 	/// Get the name of the Opus function from which the error originated.
+	#[inline]
 	pub fn function(&self) -> &'static str { self.function }
+
 	/// Get a textual description of the error provided by Opus.
-	pub fn description(&self) -> &'static str { self.description }
+	#[inline]
+	pub fn description(&self) -> &'static str { self.code.description() }
+
 	/// Get the Opus error code of the error.
+	#[inline]
 	pub fn code(&self) -> ErrorCode { self.code }
 }
 
 impl std::fmt::Display for Error {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-		write!(f, "{}: {}", self.function, self.description)
+		write!(f, "{}: {}", self.function, self.description())
 	}
 }
 
 impl std::error::Error for Error {
 	fn description(&self) -> &str {
-		self.description
+		self.code.description()
 	}
 }