Better errors (#173)

* Make errors more helpful in audio.rs

* Finish audio errors

* Add errors for data.rs

* Add font and model errors

* Add errors for texture.rs

* Move error types into error.rs

* Import texture error types

* Add RaylibError type

* Improve context of some errors

Author: AmityWilder

raylib/src/core/audio.rs

@@ -1,11 +1,12 @@
 //! Contains code related to audio. [`RaylibAudio`] plays sounds and music.
 
-use crate::error::{error, Error};
-use crate::ffi;
-use std::ffi::CString;
+use crate::{ffi, error::{AudioInitError, LoadSoundError}};
+use std::ffi::{CStr, CString};
 use std::marker::PhantomData;
 use std::path::Path;
 
+use super::error::ExportWaveError;
+
 make_thin_wrapper_lifetime!(
     /// Wave, audio wave data
     Wave,
@@ -57,21 +58,6 @@ impl AudioSample for u8 {}
 impl AudioSample for i16 {}
 impl AudioSample for f32 {}
 
-pub struct RaylibAudioInitError;
-
-impl std::fmt::Debug for RaylibAudioInitError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("RaylibAudio cannot be instantiated more then once at a time.")
-    }
-}
-impl std::fmt::Display for RaylibAudioInitError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("RaylibAudio cannot be instantiated more then once at a time.")
-    }
-}
-
-impl std::error::Error for RaylibAudioInitError {}
-
 /// This token is used to indicate audio is initialized. It's also used to create [`Wave`], [`Sound`], [`Music`], [`AudioStream`], and [`SoundAlias`].
 /// All of those have a lifetime that is bound to RaylibAudio. The compiler will disallow you from using them without ensuring that the [`RaylibAudio`] is present while doing so.
 #[derive(Debug, Clone)]
@@ -80,12 +66,15 @@ pub struct RaylibAudio(PhantomData<()>);
 impl RaylibAudio {
     /// Initializes audio device and context.
     #[inline]
-    pub fn init_audio_device() -> Result<RaylibAudio, RaylibAudioInitError> {
+    pub fn init_audio_device() -> Result<RaylibAudio, AudioInitError> {
         unsafe {
             if ffi::IsAudioDeviceReady() {
-                return Err(RaylibAudioInitError);
+                return Err(AudioInitError::DoubleInit);
             }
             ffi::InitAudioDevice();
+            if !ffi::IsAudioDeviceReady() {
+                return Err(AudioInitError::InitFailed);
+            }
         }
         Ok(RaylibAudio(PhantomData))
     }
@@ -118,32 +107,32 @@ impl RaylibAudio {
 
     /// Loads a new sound from file.
     #[inline]
-    pub fn new_sound<'aud>(&'aud self, filename: &str) -> Result<Sound<'aud>, Error> {
+    pub fn new_sound<'aud>(&'aud self, filename: &str) -> Result<Sound<'aud>, LoadSoundError> {
         let c_filename = CString::new(filename).unwrap();
         let s = unsafe { ffi::LoadSound(c_filename.as_ptr()) };
         if s.stream.buffer.is_null() {
-            return Err(error!("failed to load sound", filename));
+            return Err(LoadSoundError::LoadFailed { path: filename.into() });
         }
 
         Ok(Sound(s, self))
     }
 
     /// Loads sound from wave data.
     #[inline]
-    pub fn new_sound_from_wave<'aud>(&'aud self, wave: &Wave) -> Result<Sound<'aud>, Error> {
+    pub fn new_sound_from_wave<'aud>(&'aud self, wave: &Wave) -> Result<Sound<'aud>, LoadSoundError> {
         let s = unsafe { ffi::LoadSoundFromWave(wave.0) };
         if s.stream.buffer.is_null() {
-            return Err(error!("failed to load sound from wave"));
+            return Err(LoadSoundError::LoadFromWaveFailed);
         }
         Ok(Sound(s, self))
     }
     /// Loads wave data from file into RAM.
     #[inline]
-    pub fn new_wave<'aud>(&'aud self, filename: &str) -> Result<Wave<'aud>, Error> {
+    pub fn new_wave<'aud>(&'aud self, filename: &str) -> Result<Wave<'aud>, LoadSoundError> {
         let c_filename = CString::new(filename).unwrap();
         let w = unsafe { ffi::LoadWave(c_filename.as_ptr()) };
         if w.data.is_null() {
-            return Err(error!("Cannot load wave {}", filename));
+            return Err(LoadSoundError::LoadWaveFromFileFailed { path: filename.into() });
         }
         Ok(Wave(w, self))
     }
@@ -154,24 +143,24 @@ impl RaylibAudio {
         &'aud self,
         filetype: &str,
         bytes: &[u8],
-    ) -> Result<Wave<'aud>, Error> {
+    ) -> Result<Wave<'aud>, LoadSoundError> {
         let c_filetype = CString::new(filetype).unwrap();
         let w = unsafe {
             ffi::LoadWaveFromMemory(c_filetype.as_ptr(), bytes.as_ptr(), bytes.len() as i32)
         };
         if w.data.is_null() {
-            return Err(error!("Wave data is null. Check provided buffer data"));
+            return Err(LoadSoundError::Null);
         };
         Ok(Wave(w, self))
     }
 
     /// Loads music stream from file.
     #[inline]
-    pub fn new_music<'aud>(&'aud self, filename: &str) -> Result<Music<'aud>, Error> {
+    pub fn new_music<'aud>(&'aud self, filename: &str) -> Result<Music<'aud>, LoadSoundError> {
         let c_filename = CString::new(filename).unwrap();
         let m = unsafe { ffi::LoadMusicStream(c_filename.as_ptr()) };
         if m.stream.buffer.is_null() {
-            return Err(error!("music could not be loaded from file", filename));
+            return Err(LoadSoundError::LoadMusicFromFileFailed { path: filename.into() });
         }
         Ok(Music(m, self))
     }
@@ -182,15 +171,13 @@ impl RaylibAudio {
         &'aud self,
         filetype: &str,
         bytes: &Vec<u8>,
-    ) -> Result<Music<'aud>, Error> {
+    ) -> Result<Music<'aud>, LoadSoundError> {
         let c_filetype = CString::new(filetype).unwrap();
         let w = unsafe {
             ffi::LoadMusicStreamFromMemory(c_filetype.as_ptr(), bytes.as_ptr(), bytes.len() as i32)
         };
         if w.stream.buffer.is_null() {
-            return Err(error!(
-                "Music's buffer data data is null. Check provided buffer data"
-            ));
+            return Err(LoadSoundError::MusicNull);
         };
         Ok(Music(w, self))
     }
@@ -253,9 +240,24 @@ impl<'aud> Wave<'aud> {
 
     /// Export wave file. Extension must be .wav or .raw
     #[inline]
-    pub fn export(&self, filename: impl AsRef<Path>) -> bool {
+    pub fn export(&self, filename: impl AsRef<Path>) -> Result<(), ExportWaveError> {
         let c_filename = CString::new(filename.as_ref().to_string_lossy().as_bytes()).unwrap();
-        unsafe { ffi::ExportWave(self.0, c_filename.as_ptr()) }
+        let success = unsafe { ffi::ExportWave(self.0, c_filename.as_ptr()) };
+        if success {
+            Ok(())
+        } else {
+            // const WAV: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b".wav\0") };
+            const QOA: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b".qoa\0") };
+            // const RAW: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b".raw\0") };
+            let is_qoa = unsafe { ffi::IsFileExtension(c_filename.as_ptr(), QOA.as_ptr()) };
+            if is_qoa {
+                let samples = self.0.sampleSize as i32;
+                if samples != 16 {
+                    return Err(ExportWaveError::QoaBadSamples(self.0.sampleSize as i32));
+                }
+            }
+            Err(ExportWaveError::ExportFailed)
+        }
     }
 
     /*/// Export wave sample data to code (.h)
@@ -650,10 +652,12 @@ impl<'aud> AudioStream<'aud> {
 }
 
 impl<'bind> Sound<'bind> {
-    pub fn alias<'snd>(&'snd self) -> Result<SoundAlias<'snd, 'bind>, Error> {
+    /// Clone sound from existing sound data, clone does not own wave data
+    // NOTE: Wave data must be unallocated manually and will be shared across all clones
+    pub fn alias<'snd>(&'snd self) -> Result<SoundAlias<'snd, 'bind>, LoadSoundError> {
         let s = unsafe { ffi::LoadSoundAlias(self.0) };
         if s.stream.buffer.is_null() {
-            return Err(error!("failed to load sound from wave"));
+            return Err(LoadSoundError::LoadFromWaveFailed);
         }
         Ok(SoundAlias(s, PhantomData))
     }

raylib/src/core/data.rs

@@ -3,10 +3,7 @@ use std::{
     alloc::Layout, ffi::{c_char, CString}, ops::{Deref, DerefMut}, path::Path, ptr::NonNull
 };
 
-use crate::{
-    error::{error, Error},
-    ffi,
-};
+use crate::{ffi, error::{AllocationError, CompressionError}};
 
 /// A wrapper acting as an owned buffer for Raylib-allocated memory.
 /// Automatically releases the memory with [`ffi::MemFree()`] when dropped.
@@ -115,22 +112,22 @@ impl<T: Copy> DataBuf<T> {
     /// # Panics
     ///
     /// This method may panic if the pointer returned by [`ffi::MemAlloc`] is unaligned.
-    pub fn alloc(count: i32) -> Result<Self, Error> {
+    pub fn alloc(count: i32) -> Result<Self, AllocationError> {
         if count >= 1 {
             let count = count as usize;
             match Layout::array::<T>(count) {
-                Err(_e) => Err(error!("memory request does not produce a valid layout")), // I would like to display `e` if possible
+                Err(_e) => Err(AllocationError::InvalidLayout), // I would like to display `e` if possible
                 Ok(layout) => {
                     let size = layout.size();
                     if size <= u32::MAX as usize {
                         if let Some(buf) = NonNull::new(unsafe { ffi::MemAlloc(size as u32) }.cast()) {
                             assert!(buf.is_aligned(), "allocated buffer should always be aligned");
                             Ok(Self { buf, len: count })
-                        } else { Err(error!("memory request exceeds capacity")) }
-                    } else { Err(error!("memory request exceeds unsigned integer maximum")) }
+                        } else { Err(AllocationError::ExceedsCapacity) }
+                    } else { Err(AllocationError::ExceedsUIntMax) }
                 }
             }
-        } else { Err(error!("cannot allocate less than 1 element")) }
+        } else { Err(AllocationError::SubMinSize) }
     }
 
     /// Reallocate memory already managed by Raylib
@@ -146,11 +143,11 @@ impl<T: Copy> DataBuf<T> {
     /// # Panics
     ///
     /// This method may panic if the pointer returned by [`ffi::MemRealloc`] is unaligned.
-    pub fn realloc(&mut self, new_count: i32) -> Result<(), Error> {
+    pub fn realloc(&mut self, new_count: i32) -> Result<(), AllocationError> {
         if new_count >= 1 {
             let new_count = new_count as usize;
             match Layout::array::<T>(new_count) {
-                Err(_e) => Err(error!("memory request does not produce a valid layout")), // I would like to display `e` if possible
+                Err(_e) => Err(AllocationError::InvalidLayout), // I would like to display `e` if possible
                 Ok(layout) => {
                     let size = layout.size();
                     if size <= u32::MAX as usize {
@@ -159,11 +156,11 @@ impl<T: Copy> DataBuf<T> {
                             self.buf = buf;
                             self.len = new_count;
                             Ok(())
-                        } else { Err(error!("memory request exceeds capacity")) }
-                    } else { Err(error!("memory request exceeds unsigned integer maximum")) }
+                        } else { Err(AllocationError::ExceedsCapacity) }
+                    } else { Err(AllocationError::ExceedsUIntMax) }
                 }
             }
-        } else { Err(error!("cannot allocate less than 1 element")) }
+        } else { Err(AllocationError::SubMinSize) }
     }
 }
 
@@ -174,14 +171,14 @@ impl<T: Copy> DataBuf<T> {
 /// let expected: &[u8] = &[1, 5, 0, 250, 255, 49, 49, 49, 49, 49];
 /// assert_eq!(data.as_ref(), expected);
 /// ```
-pub fn compress_data(data: &[u8]) -> Result<DataBuf<u8>, Error> {
+pub fn compress_data(data: &[u8]) -> Result<DataBuf<u8>, CompressionError> {
     let mut out_length: i32 = 0;
     // CompressData doesn't actually modify the data, but the header is wrong
     let buffer = {
         unsafe { ffi::CompressData(data.as_ptr() as *mut _, data.len() as i32, &mut out_length) }
     };
     DataBuf::new(buffer, out_length)
-        .ok_or_else(|| error!("could not compress data"))
+        .ok_or_else(|| CompressionError::CompressionFailed)
 }
 
 /// Decompress data (DEFLATE algorythm)
@@ -192,7 +189,7 @@ pub fn compress_data(data: &[u8]) -> Result<DataBuf<u8>, Error> {
 /// let data = decompress_data(input).unwrap();
 /// assert_eq!(data.as_ref(), expected);
 /// ```
-pub fn decompress_data(data: &[u8]) -> Result<DataBuf<u8>, Error> {
+pub fn decompress_data(data: &[u8]) -> Result<DataBuf<u8>, CompressionError> {
     #[cfg(debug_assertions)]
     println!("{:?}", data.len());
 
@@ -202,7 +199,7 @@ pub fn decompress_data(data: &[u8]) -> Result<DataBuf<u8>, Error> {
         unsafe { ffi::DecompressData(data.as_ptr() as *mut _, data.len() as i32, &mut out_length) }
     };
     DataBuf::new(buffer, out_length)
-        .ok_or_else(|| error!("could not compress data"))
+        .ok_or_else(|| CompressionError::CompressionFailed)
 }
 
 #[cfg(unix)]