rust3ds
/
ctru-rs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Improve calling ``ctru_sys `` functions ergonomics 

Now instead of handling the error number manually, you can use ``LibCtruError(ctru_sys::xxx())?`` for the cases where ``if r < 0`` executes ``Err(r.into())``

Most changes are migrations to the new system, relevant code changes are in ``src/error.rs``
pull/74/head
TechiePi 2 years ago
parent
ec07231e99
commit
22183d8765
10 changed files with 176 additions and 384 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 33
      ctru-rs/src/error.rs
  2. 1
      ctru-rs/src/lib.rs
  3. 7
      ctru-rs/src/romfs.rs
  4. 14
      ctru-rs/src/services/apt.rs
  5. 299
      ctru-rs/src/services/cam.rs
  6. 43
      ctru-rs/src/services/cfgu.rs
  7. 7
      ctru-rs/src/services/hid.rs
  8. 20
      ctru-rs/src/services/ps.rs
  9. 6
      ctru-rs/src/services/soc.rs
  10. 14
      ctru-rs/src/services/sslc.rs

33
ctru-rs/src/error.rs
Unescape View File

@ -1,11 +1,38 @@
use std::error; use std::error;
use std::ffi::CStr; use std::ffi::CStr;
use std::fmt; use std::fmt;
use std::ops::{ControlFlow, FromResidual, Try};
use ctru_sys::result::{R_DESCRIPTION, R_LEVEL, R_MODULE, R_SUMMARY}; use ctru_sys::result::{R_DESCRIPTION, R_LEVEL, R_MODULE, R_SUMMARY};
pub type Result<T> = ::std::result::Result<T, Error>; pub type Result<T> = ::std::result::Result<T, Error>;
#[derive(Debug, Clone, PartialEq, PartialOrd)]
#[repr(transparent)]
pub(crate) struct LibCtruError(pub i32);
impl Try for LibCtruError {
type Output = ();
type Residual = crate::Result<core::convert::Infallible>;
fn from_output(_: Self::Output) -> Self {
Self(0)
}
fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
match self.0 {
0 => ControlFlow::Continue(()),
_ => ControlFlow::Break(Err(self.into()))
}
}
}
impl FromResidual for LibCtruError {
fn from_residual(_: <Self as Try>::Residual) -> Self {
Self(1)
}
}
/// The error type returned by all libctru functions. /// The error type returned by all libctru functions.
#[non_exhaustive] #[non_exhaustive]
pub enum Error { pub enum Error {
@ -39,6 +66,12 @@ impl From<ctru_sys::Result> for Error {
} }
} }
impl From<LibCtruError> for Error {
fn from(err: LibCtruError) -> Self {
Self::Os(err.0)
}
}
impl fmt::Debug for Error { impl fmt::Debug for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {

1
ctru-rs/src/lib.rs
Unescape View File

@ -2,6 +2,7 @@
#![crate_name = "ctru"] #![crate_name = "ctru"]
#![feature(test)] #![feature(test)]
#![feature(custom_test_frameworks)] #![feature(custom_test_frameworks)]
#![feature(try_trait_v2)]
#![test_runner(test_runner::run)] #![test_runner(test_runner::run)]
extern "C" fn services_deinit() { extern "C" fn services_deinit() {

7
ctru-rs/src/romfs.rs
Unescape View File

@ -13,6 +13,7 @@
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::ffi::CStr; use std::ffi::CStr;
use std::sync::Mutex; use std::sync::Mutex;
use crate::error::LibCtruError;
use crate::services::ServiceReference; use crate::services::ServiceReference;
@ -30,11 +31,7 @@ impl RomFS {
true, true,
|| { || {
let mount_name = CStr::from_bytes_with_nul(b"romfs\0").unwrap(); let mount_name = CStr::from_bytes_with_nul(b"romfs\0").unwrap();
let r = unsafe { ctru_sys::romfsMountSelf(mount_name.as_ptr()) }; LibCtruError(unsafe { ctru_sys::romfsMountSelf(mount_name.as_ptr()) })?;
if r < 0 {
return Err(r.into());
}
Ok(()) Ok(())
}, },
|| { || {

14
ctru-rs/src/services/apt.rs
Unescape View File

@ -1,16 +1,14 @@
use crate::error::LibCtruError;
pub struct Apt(()); pub struct Apt(());
impl Apt { impl Apt {
pub fn init() -> crate::Result<Apt> { pub fn init() -> crate::Result<Apt> {
unsafe { unsafe {
let r = ctru_sys::aptInit(); LibCtruError(ctru_sys::aptInit())?;
if r < 0 {
Err(r.into())
} else {
Ok(Apt(())) Ok(Apt(()))
} }
} }
}
pub fn main_loop(&self) -> bool { pub fn main_loop(&self) -> bool {
unsafe { ctru_sys::aptMainLoop() } unsafe { ctru_sys::aptMainLoop() }
@ -18,15 +16,11 @@ impl Apt {
pub fn set_app_cpu_time_limit(&self, percent: u32) -> crate::Result<()> { pub fn set_app_cpu_time_limit(&self, percent: u32) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::APT_SetAppCpuTimeLimit(percent); LibCtruError(ctru_sys::APT_SetAppCpuTimeLimit(percent))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
} }
}
impl Drop for Apt { impl Drop for Apt {
fn drop(&mut self) { fn drop(&mut self) {

299
ctru-rs/src/services/cam.rs
Unescape View File

@ -7,6 +7,7 @@ use crate::services::gspgpu::FramebufferFormat;
use bitflags::bitflags; use bitflags::bitflags;
use ctru_sys::Handle; use ctru_sys::Handle;
use std::time::Duration; use std::time::Duration;
use crate::error::LibCtruError;
/// A reference-counted handle to the CAM service and the usable cameras. /// A reference-counted handle to the CAM service and the usable cameras.
/// The service is closed when all instances of this struct fall out of scope. /// The service is closed when all instances of this struct fall out of scope.
@ -267,27 +268,18 @@ impl BothOutwardCam {
brightness_synchronization: bool, brightness_synchronization: bool,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetBrightnessSynchronization(brightness_synchronization); LibCtruError(ctru_sys::CAMU_SetBrightnessSynchronization(brightness_synchronization))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
fn synchronize_vsync_timing(&self) -> crate::Result<()> { fn synchronize_vsync_timing(&self) -> crate::Result<()> {
unsafe { unsafe {
let r = LibCtruError(ctru_sys::CAMU_SynchronizeVsyncTiming(ctru_sys::SELECT_OUT1, ctru_sys::SELECT_OUT2))?;
ctru_sys::CAMU_SynchronizeVsyncTiming(ctru_sys::SELECT_OUT1, ctru_sys::SELECT_OUT2);
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
} }
}
impl Camera for BothOutwardCam { impl Camera for BothOutwardCam {
fn camera_as_raw(&self) -> ctru_sys::u32_ { fn camera_as_raw(&self) -> ctru_sys::u32_ {
@ -313,72 +305,52 @@ pub trait Camera {
fn is_busy(&self) -> crate::Result<bool> { fn is_busy(&self) -> crate::Result<bool> {
unsafe { unsafe {
let mut is_busy = false; let mut is_busy = false;
let r = ctru_sys::CAMU_IsBusy(&mut is_busy, self.port_as_raw()); LibCtruError(ctru_sys::CAMU_IsBusy(&mut is_busy, self.port_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(is_busy) Ok(is_busy)
} }
} }
}
/// Returns the maximum amount of transfer bytes based on the view size, trimming, and other /// Returns the maximum amount of transfer bytes based on the view size, trimming, and other
/// modifications set to the camera /// modifications set to the camera
fn get_transfer_bytes(&self) -> crate::Result<u32> { fn get_transfer_bytes(&self) -> crate::Result<u32> {
unsafe { unsafe {
let mut transfer_bytes = 0; let mut transfer_bytes = 0;
let r = ctru_sys::CAMU_GetTransferBytes(&mut transfer_bytes, self.port_as_raw()); LibCtruError(ctru_sys::CAMU_GetTransferBytes(&mut transfer_bytes, self.port_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(transfer_bytes) Ok(transfer_bytes)
} }
} }
}
/// Sets whether or not the camera should trim the image based on parameters set by /// Sets whether or not the camera should trim the image based on parameters set by
/// [Camera::set_trimming_params] /// [Camera::set_trimming_params]
fn set_trimming(&mut self, enabled: bool) -> crate::Result<()> { fn set_trimming(&mut self, enabled: bool) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetTrimming(self.port_as_raw(), enabled); LibCtruError(ctru_sys::CAMU_SetTrimming(self.port_as_raw(), enabled))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Returns whether or not trimming is currently enabled for the camera /// Returns whether or not trimming is currently enabled for the camera
fn is_trimming_enabled(&self) -> crate::Result<bool> { fn is_trimming_enabled(&self) -> crate::Result<bool> {
unsafe { unsafe {
let mut trimming = false; let mut trimming = false;
let r = ctru_sys::CAMU_IsTrimming(&mut trimming, self.port_as_raw()); LibCtruError(ctru_sys::CAMU_IsTrimming(&mut trimming, self.port_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(trimming) Ok(trimming)
} }
} }
}
/// Sets trimming parameters based on coordinates specified inside a [CamTrimmingParams] /// Sets trimming parameters based on coordinates specified inside a [CamTrimmingParams]
fn set_trimming_params(&mut self, params: CamTrimmingParams) -> crate::Result<()> { fn set_trimming_params(&mut self, params: CamTrimmingParams) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetTrimmingParams( LibCtruError(ctru_sys::CAMU_SetTrimmingParams(
self.port_as_raw(), self.port_as_raw(),
params.x_start, params.x_start,
params.y_start, params.y_start,
params.x_end, params.x_end,
params.y_end, params.y_end,
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Returns the set [CamTrimmingParams] from the camera /// Returns the set [CamTrimmingParams] from the camera
fn get_trimming_params(&self) -> crate::Result<CamTrimmingParams> { fn get_trimming_params(&self) -> crate::Result<CamTrimmingParams> {
@ -387,16 +359,14 @@ pub trait Camera {
let mut y_start = 0; let mut y_start = 0;
let mut x_end = 0; let mut x_end = 0;
let mut y_end = 0; let mut y_end = 0;
let r = ctru_sys::CAMU_GetTrimmingParams( LibCtruError(ctru_sys::CAMU_GetTrimmingParams(
&mut x_start, &mut x_start,
&mut y_start, &mut y_start,
&mut x_end, &mut x_end,
&mut y_end, &mut y_end,
self.port_as_raw(), self.port_as_raw(),
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(CamTrimmingParams { Ok(CamTrimmingParams {
x_start, x_start,
y_start, y_start,
@ -405,7 +375,6 @@ pub trait Camera {
}) })
} }
} }
}
/// Sets the trimming parameters revolving around the center of the image. /// Sets the trimming parameters revolving around the center of the image.
/// The new width will be `trim_width / 2` to the left and right of the center. /// The new width will be `trim_width / 2` to the left and right of the center.
@ -418,44 +387,32 @@ pub trait Camera {
cam_height: i16, cam_height: i16,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetTrimmingParamsCenter( LibCtruError(ctru_sys::CAMU_SetTrimmingParamsCenter(
self.port_as_raw(), self.port_as_raw(),
trim_width, trim_width,
trim_height, trim_height,
cam_width, cam_width,
cam_height, cam_height,
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the exposure level of the camera /// Sets the exposure level of the camera
fn set_exposure(&mut self, exposure: i8) -> crate::Result<()> { fn set_exposure(&mut self, exposure: i8) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetExposure(self.camera_as_raw(), exposure); LibCtruError(ctru_sys::CAMU_SetExposure(self.camera_as_raw(), exposure))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the white balance mod of the camera based on the passed [CamWhiteBalance] argument /// Sets the white balance mod of the camera based on the passed [CamWhiteBalance] argument
fn set_white_balance(&mut self, white_balance: CamWhiteBalance) -> crate::Result<()> { fn set_white_balance(&mut self, white_balance: CamWhiteBalance) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetWhiteBalance(self.camera_as_raw(), white_balance.bits()); LibCtruError(ctru_sys::CAMU_SetWhiteBalance(self.camera_as_raw(), white_balance.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the white balance mode of the camera based on the passed [CamWhiteBalance] argument /// Sets the white balance mode of the camera based on the passed [CamWhiteBalance] argument
// TODO: Explain base up // TODO: Explain base up
@ -464,92 +421,63 @@ pub trait Camera {
white_balance: CamWhiteBalance, white_balance: CamWhiteBalance,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetWhiteBalanceWithoutBaseUp( LibCtruError(ctru_sys::CAMU_SetWhiteBalanceWithoutBaseUp(
self.camera_as_raw(), self.camera_as_raw(),
white_balance.bits(), white_balance.bits(),
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the sharpness of the camera /// Sets the sharpness of the camera
fn set_sharpness(&mut self, sharpness: i8) -> crate::Result<()> { fn set_sharpness(&mut self, sharpness: i8) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetSharpness(self.camera_as_raw(), sharpness); LibCtruError(ctru_sys::CAMU_SetSharpness(self.camera_as_raw(), sharpness))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets whether auto exposure is enabled or disabled for the camera /// Sets whether auto exposure is enabled or disabled for the camera
fn set_auto_exposure(&mut self, enabled: bool) -> crate::Result<()> { fn set_auto_exposure(&mut self, enabled: bool) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetAutoExposure(self.camera_as_raw(), enabled); LibCtruError(ctru_sys::CAMU_SetAutoExposure(self.camera_as_raw(), enabled))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Returns true if auto exposure is enabled for the camera /// Returns true if auto exposure is enabled for the camera
fn is_auto_exposure_enabled(&self) -> crate::Result<bool> { fn is_auto_exposure_enabled(&self) -> crate::Result<bool> {
unsafe { unsafe {
let mut enabled = false; let mut enabled = false;
let r = ctru_sys::CAMU_IsAutoExposure(&mut enabled, self.camera_as_raw()); LibCtruError(ctru_sys::CAMU_IsAutoExposure(&mut enabled, self.camera_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(enabled) Ok(enabled)
} }
} }
}
/// Sets whether auto white balance is enabled or disabled for the camera /// Sets whether auto white balance is enabled or disabled for the camera
fn set_auto_white_balance(&mut self, enabled: bool) -> crate::Result<()> { fn set_auto_white_balance(&mut self, enabled: bool) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetAutoWhiteBalance(self.camera_as_raw(), enabled); LibCtruError(ctru_sys::CAMU_SetAutoWhiteBalance(self.camera_as_raw(), enabled))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Returns true if auto white balance is enabled for the camera /// Returns true if auto white balance is enabled for the camera
fn is_auto_white_balance_enabled(&self) -> crate::Result<bool> { fn is_auto_white_balance_enabled(&self) -> crate::Result<bool> {
unsafe { unsafe {
let mut enabled = false; let mut enabled = false;
let r = ctru_sys::CAMU_IsAutoWhiteBalance(&mut enabled, self.camera_as_raw()); LibCtruError(ctru_sys::CAMU_IsAutoWhiteBalance(&mut enabled, self.camera_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(enabled) Ok(enabled)
} }
} }
}
/// Sets the flip direction of the camera's image based on the passed [CamFlip] argument /// Sets the flip direction of the camera's image based on the passed [CamFlip] argument
fn flip_image(&mut self, flip: CamFlip) -> crate::Result<()> { fn flip_image(&mut self, flip: CamFlip) -> crate::Result<()> {
unsafe { unsafe {
let r = LibCtruError(ctru_sys::CAMU_FlipImage(self.camera_as_raw(), flip.bits(), ctru_sys::CONTEXT_A))?;
ctru_sys::CAMU_FlipImage(self.camera_as_raw(), flip.bits(), ctru_sys::CONTEXT_A);
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the image resolution of the camera in detail /// Sets the image resolution of the camera in detail
/// ///
@ -571,7 +499,7 @@ pub trait Camera {
crop_1: (i16, i16), crop_1: (i16, i16),
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetDetailSize( LibCtruError(ctru_sys::CAMU_SetDetailSize(
self.camera_as_raw(), self.camera_as_raw(),
width, width,
height, height,
@ -580,105 +508,72 @@ pub trait Camera {
crop_1.0, crop_1.0,
crop_1.1, crop_1.1,
ctru_sys::CONTEXT_A, ctru_sys::CONTEXT_A,
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the view size of the camera based on the passed [CamSize] argument. /// Sets the view size of the camera based on the passed [CamSize] argument.
fn set_view_size(&mut self, size: CamSize) -> crate::Result<()> { fn set_view_size(&mut self, size: CamSize) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetSize(self.camera_as_raw(), size.bits(), ctru_sys::CONTEXT_A); LibCtruError(ctru_sys::CAMU_SetSize(self.camera_as_raw(), size.bits(), ctru_sys::CONTEXT_A))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the frame rate of the camera based on the passed [CamFrameRate] argument. /// Sets the frame rate of the camera based on the passed [CamFrameRate] argument.
fn set_frame_rate(&mut self, frame_rate: CamFrameRate) -> crate::Result<()> { fn set_frame_rate(&mut self, frame_rate: CamFrameRate) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetFrameRate(self.camera_as_raw(), frame_rate.bits()); LibCtruError(ctru_sys::CAMU_SetFrameRate(self.camera_as_raw(), frame_rate.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the photo mode of the camera based on the passed [CamPhotoMode] argument. /// Sets the photo mode of the camera based on the passed [CamPhotoMode] argument.
fn set_photo_mode(&mut self, photo_mode: CamPhotoMode) -> crate::Result<()> { fn set_photo_mode(&mut self, photo_mode: CamPhotoMode) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetPhotoMode(self.camera_as_raw(), photo_mode.bits()); LibCtruError(ctru_sys::CAMU_SetPhotoMode(self.camera_as_raw(), photo_mode.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the effect of the camera based on the passed [CamEffect] argument. /// Sets the effect of the camera based on the passed [CamEffect] argument.
/// ///
/// Multiple effects can be set at once by combining the bitflags of [CamEffect] /// Multiple effects can be set at once by combining the bitflags of [CamEffect]
fn set_effect(&mut self, effect: CamEffect) -> crate::Result<()> { fn set_effect(&mut self, effect: CamEffect) -> crate::Result<()> {
unsafe { unsafe {
let r = LibCtruError(ctru_sys::CAMU_SetEffect(self.camera_as_raw(), effect.bits(), ctru_sys::CONTEXT_A))?;
ctru_sys::CAMU_SetEffect(self.camera_as_raw(), effect.bits(), ctru_sys::CONTEXT_A);
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the contrast of the camera based on the passed [CamContrast] argument. /// Sets the contrast of the camera based on the passed [CamContrast] argument.
fn set_contrast(&mut self, contrast: CamContrast) -> crate::Result<()> { fn set_contrast(&mut self, contrast: CamContrast) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetContrast(self.camera_as_raw(), contrast.bits()); LibCtruError(ctru_sys::CAMU_SetContrast(self.camera_as_raw(), contrast.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the lens correction of the camera based on the passed [CamLensCorrection] argument. /// Sets the lens correction of the camera based on the passed [CamLensCorrection] argument.
fn set_lens_correction(&mut self, lens_correction: CamLensCorrection) -> crate::Result<()> { fn set_lens_correction(&mut self, lens_correction: CamLensCorrection) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetLensCorrection(self.camera_as_raw(), lens_correction.bits()); LibCtruError(ctru_sys::CAMU_SetLensCorrection(self.camera_as_raw(), lens_correction.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the output format of the camera based on the passed [CamOutputFormat] argument. /// Sets the output format of the camera based on the passed [CamOutputFormat] argument.
fn set_output_format(&mut self, format: CamOutputFormat) -> crate::Result<()> { fn set_output_format(&mut self, format: CamOutputFormat) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetOutputFormat( LibCtruError(ctru_sys::CAMU_SetOutputFormat(
self.camera_as_raw(), self.camera_as_raw(),
format.bits(), format.bits(),
ctru_sys::CONTEXT_A, ctru_sys::CONTEXT_A,
); ))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the region in which auto exposure should be based on. /// Sets the region in which auto exposure should be based on.
/// ///
@ -696,14 +591,10 @@ pub trait Camera {
height: i16, height: i16,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetAutoExposureWindow(self.camera_as_raw(), x, y, width, height); LibCtruError(ctru_sys::CAMU_SetAutoExposureWindow(self.camera_as_raw(), x, y, width, height))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the region in which auto white balance should be based on. /// Sets the region in which auto white balance should be based on.
/// ///
@ -721,27 +612,18 @@ pub trait Camera {
height: i16, height: i16,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = LibCtruError(ctru_sys::CAMU_SetAutoWhiteBalanceWindow(self.camera_as_raw(), x, y, width, height))?;
ctru_sys::CAMU_SetAutoWhiteBalanceWindow(self.camera_as_raw(), x, y, width, height);
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets whether the noise filter should be enabled or disabled for the camera /// Sets whether the noise filter should be enabled or disabled for the camera
fn set_noise_filter(&mut self, enabled: bool) -> crate::Result<()> { fn set_noise_filter(&mut self, enabled: bool) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetNoiseFilter(self.camera_as_raw(), enabled); LibCtruError(ctru_sys::CAMU_SetNoiseFilter(self.camera_as_raw(), enabled))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Sets the image quality calibration data for the camera based on the passed in /// Sets the image quality calibration data for the camera based on the passed in
/// [ImageQualityCalibrationData] argument /// [ImageQualityCalibrationData] argument
@ -750,40 +632,28 @@ pub trait Camera {
data: ImageQualityCalibrationData, data: ImageQualityCalibrationData,
) -> crate::Result<()> { ) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetImageQualityCalibrationData(data.0); LibCtruError(ctru_sys::CAMU_SetImageQualityCalibrationData(data.0))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Returns the current [ImageQualityCalibrationData] for the camera /// Returns the current [ImageQualityCalibrationData] for the camera
fn get_image_quality_calibration_data(&self) -> crate::Result<ImageQualityCalibrationData> { fn get_image_quality_calibration_data(&self) -> crate::Result<ImageQualityCalibrationData> {
unsafe { unsafe {
let mut data = ImageQualityCalibrationData::default(); let mut data = ImageQualityCalibrationData::default();
let r = ctru_sys::CAMU_GetImageQualityCalibrationData(&mut data.0); LibCtruError(ctru_sys::CAMU_GetImageQualityCalibrationData(&mut data.0))?;
if r < 0 {
Err(r.into())
} else {
Ok(data) Ok(data)
} }
} }
}
/// Sets the camera as the current sleep camera /// Sets the camera as the current sleep camera
// TODO: Explain sleep camera // TODO: Explain sleep camera
fn set_sleep_camera(&mut self) -> crate::Result<()> { fn set_sleep_camera(&mut self) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_SetSleepCamera(self.camera_as_raw()); LibCtruError(ctru_sys::CAMU_SetSleepCamera(self.camera_as_raw()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
}
/// Requests the camera to take a picture and returns a vector containing the image bytes. /// Requests the camera to take a picture and returns a vector containing the image bytes.
/// ///
@ -804,12 +674,8 @@ pub trait Camera {
) -> crate::Result<Vec<u8>> { ) -> crate::Result<Vec<u8>> {
let transfer_unit = unsafe { let transfer_unit = unsafe {
let mut buf_size = 0; let mut buf_size = 0;
let r = ctru_sys::CAMU_GetMaxBytes(&mut buf_size, width as i16, height as i16); LibCtruError(ctru_sys::CAMU_GetMaxBytes(&mut buf_size, width as i16, height as i16))?;
if r < 0 { Ok::<u32, i32>(buf_size)
Err(crate::Error::from(r))
} else {
Ok(buf_size)
}
}?; }?;
let screen_size = u32::from(width) * u32::from(width) * 2; let screen_size = u32::from(width) * u32::from(width) * 2;
@ -817,83 +683,40 @@ pub trait Camera {
let mut buf = vec![0u8; usize::try_from(screen_size).unwrap()]; let mut buf = vec![0u8; usize::try_from(screen_size).unwrap()];
unsafe { unsafe {
let r = ctru_sys::CAMU_SetTransferBytes( LibCtruError(ctru_sys::CAMU_SetTransferBytes(
self.port_as_raw(), self.port_as_raw(),
transfer_unit, transfer_unit,
width as i16, width as i16,
height as i16, height as i16,
); ))?;
if r < 0 {
return Err(r.into());
}
}; };
unsafe { unsafe {
let r = ctru_sys::CAMU_Activate(self.camera_as_raw()); LibCtruError(ctru_sys::CAMU_Activate(self.camera_as_raw()))?;
if r < 0 { LibCtruError(ctru_sys::CAMU_ClearBuffer(self.port_as_raw()))?;
return Err(r.into()); LibCtruError(ctru_sys::CAMU_StartCapture(self.port_as_raw()))?;
}
};
unsafe {
let r = ctru_sys::CAMU_ClearBuffer(self.port_as_raw());
if r < 0 {
return Err(r.into());
}
};
unsafe {
let r = ctru_sys::CAMU_StartCapture(self.port_as_raw());
if r < 0 {
return Err(r.into());
}
}; };
let receive_event = unsafe { let receive_event = unsafe {
let mut completion_handle: Handle = 0; let mut completion_handle: Handle = 0;
let r = ctru_sys::CAMU_SetReceiving( LibCtruError(ctru_sys::CAMU_SetReceiving(
&mut completion_handle, &mut completion_handle,
buf.as_mut_ptr() as *mut ::libc::c_void, buf.as_mut_ptr() as *mut ::libc::c_void,
self.port_as_raw(), self.port_as_raw(),
screen_size, screen_size,
transfer_unit.try_into().unwrap(), transfer_unit.try_into().unwrap(),
); ))?;
if r < 0 { Ok::<Handle, i32>(completion_handle)
Err(crate::Error::from(r))
} else {
Ok(completion_handle)
}
}?; }?;
unsafe { unsafe {
let r = ctru_sys::svcWaitSynchronization( LibCtruError(ctru_sys::svcWaitSynchronization(
receive_event, receive_event,
timeout.as_nanos().try_into().unwrap(), timeout.as_nanos().try_into().unwrap(),
); ))?;
if r < 0 { LibCtruError(ctru_sys::CAMU_StopCapture(self.port_as_raw()))?;
return Err(r.into()); LibCtruError(ctru_sys::svcCloseHandle(receive_event))?;
} LibCtruError(ctru_sys::CAMU_Activate(ctru_sys::SELECT_NONE))?;
};
unsafe {
let r = ctru_sys::CAMU_StopCapture(self.port_as_raw());
if r < 0 {
return Err(r.into());
}
};
unsafe {
let r = ctru_sys::svcCloseHandle(receive_event);
if r < 0 {
return Err(r.into());
}
};
unsafe {
let r = ctru_sys::CAMU_Activate(ctru_sys::SELECT_NONE);
if r < 0 {
return Err(r.into());
}
}; };
Ok(buf) Ok(buf)
@ -910,10 +733,7 @@ impl Cam {
/// rare in practice. /// rare in practice.
pub fn init() -> crate::Result<Cam> { pub fn init() -> crate::Result<Cam> {
unsafe { unsafe {
let r = ctru_sys::camInit(); LibCtruError(ctru_sys::camInit())?;
if r < 0 {
Err(r.into())
} else {
Ok(Cam { Ok(Cam {
inner_cam: InwardCam, inner_cam: InwardCam,
outer_right_cam: OutwardRightCam, outer_right_cam: OutwardRightCam,
@ -922,20 +742,15 @@ impl Cam {
}) })
} }
} }
}
/// Plays the specified sound based on the [CamShutterSoundType] argument /// Plays the specified sound based on the [CamShutterSoundType] argument
pub fn play_shutter_sound(&self, sound: CamShutterSoundType) -> crate::Result<()> { pub fn play_shutter_sound(&self, sound: CamShutterSoundType) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::CAMU_PlayShutterSound(sound.bits()); LibCtruError(ctru_sys::CAMU_PlayShutterSound(sound.bits()))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
} }
}
impl Drop for Cam { impl Drop for Cam {
fn drop(&mut self) { fn drop(&mut self) {

43
ctru-rs/src/services/cfgu.rs
Unescape View File

@ -2,6 +2,8 @@
//! //!
//! This module contains basic methods to retrieve and change configuration from the console. //! This module contains basic methods to retrieve and change configuration from the console.
use crate::error::LibCtruError;
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
#[repr(u32)] #[repr(u32)]
pub enum Region { pub enum Region {
@ -60,79 +62,50 @@ impl Cfgu {
/// as many times as desired and the service will not exit until all /// as many times as desired and the service will not exit until all
/// instances of Cfgu drop out of scope. /// instances of Cfgu drop out of scope.
pub fn init() -> crate::Result<Cfgu> { pub fn init() -> crate::Result<Cfgu> {
unsafe { LibCtruError(unsafe { ctru_sys::cfguInit() })?;
let r = ctru_sys::cfguInit();
if r < 0 {
Err(r.into())
} else {
Ok(Cfgu(())) Ok(Cfgu(()))
} }
}
}
/// Gets system region from secure info /// Gets system region from secure info
pub fn get_region(&self) -> crate::Result<Region> { pub fn get_region(&self) -> crate::Result<Region> {
let mut region: u8 = 0; let mut region: u8 = 0;
let r = unsafe { ctru_sys::CFGU_SecureInfoGetRegion(&mut region) }; LibCtruError(unsafe { ctru_sys::CFGU_SecureInfoGetRegion(&mut region) })?;
if r < 0 {
Err(r.into())
} else {
// The system shouldn't give an invalid value
Ok(Region::try_from(region).unwrap()) Ok(Region::try_from(region).unwrap())
} }
}
/// Gets system's model /// Gets system's model
pub fn get_model(&self) -> crate::Result<SystemModel> { pub fn get_model(&self) -> crate::Result<SystemModel> {
let mut model: u8 = 0; let mut model: u8 = 0;
let r = unsafe { ctru_sys::CFGU_GetSystemModel(&mut model) }; LibCtruError(unsafe { ctru_sys::CFGU_GetSystemModel(&mut model) })?;
if r < 0 {
Err(r.into())
} else {
// The system shouldn't give an invalid value
Ok(SystemModel::try_from(model).unwrap()) Ok(SystemModel::try_from(model).unwrap())
} }
}
/// Gets system's language /// Gets system's language
pub fn get_language(&self) -> crate::Result<Language> { pub fn get_language(&self) -> crate::Result<Language> {
let mut language: u8 = 0; let mut language: u8 = 0;
let r = unsafe { ctru_sys::CFGU_GetSystemLanguage(&mut language) }; LibCtruError(unsafe { ctru_sys::CFGU_GetSystemLanguage(&mut language) })?;
if r < 0 {
Err(r.into())
} else {
// The system shouldn't give an invalid value
Ok(Language::try_from(language).unwrap()) Ok(Language::try_from(language).unwrap())
} }
}
/// Checks if NFC is supported by the console /// Checks if NFC is supported by the console
pub fn is_nfc_supported(&self) -> crate::Result<bool> { pub fn is_nfc_supported(&self) -> crate::Result<bool> {
let mut supported: bool = false; let mut supported: bool = false;
let r = unsafe { ctru_sys::CFGU_IsNFCSupported(&mut supported) }; LibCtruError(unsafe { ctru_sys::CFGU_IsNFCSupported(&mut supported) })?;
if r < 0 {
Err(r.into())
} else {
Ok(supported) Ok(supported)
} }
}
/// Check if the console is from the 2DS family (2DS, New2DS, New2DSXL) /// Check if the console is from the 2DS family (2DS, New2DS, New2DSXL)
pub fn is_2ds_family(&self) -> crate::Result<bool> { pub fn is_2ds_family(&self) -> crate::Result<bool> {
let mut is_2ds_family: u8 = 0; let mut is_2ds_family: u8 = 0;
let r = unsafe { ctru_sys::CFGU_GetModelNintendo2DS(&mut is_2ds_family) }; LibCtruError(unsafe { ctru_sys::CFGU_GetModelNintendo2DS(&mut is_2ds_family) })?;
if r < 0 {
Err(r.into())
} else {
Ok(is_2ds_family == 0) Ok(is_2ds_family == 0)
} }
} }
}
impl Drop for Cfgu { impl Drop for Cfgu {
fn drop(&mut self) { fn drop(&mut self) {

7
ctru-rs/src/services/hid.rs
Unescape View File

@ -4,6 +4,7 @@
//! and circle pad information. It also provides information from the sound volume slider, //! and circle pad information. It also provides information from the sound volume slider,
//! the accelerometer, and the gyroscope. //! the accelerometer, and the gyroscope.
use crate::error::LibCtruError;
bitflags::bitflags! { bitflags::bitflags! {
/// A set of flags corresponding to the button and directional pad /// A set of flags corresponding to the button and directional pad
/// inputs on the 3DS /// inputs on the 3DS
@ -62,14 +63,10 @@ pub struct CirclePosition(ctru_sys::circlePosition);
impl Hid { impl Hid {
pub fn init() -> crate::Result<Hid> { pub fn init() -> crate::Result<Hid> {
unsafe { unsafe {
let r = ctru_sys::hidInit(); LibCtruError(ctru_sys::hidInit())?;
if r < 0 {
Err(r.into())
} else {
Ok(Hid(())) Ok(Hid(()))
} }
} }
}
/// Scans the HID service for all user input occurring on the current /// Scans the HID service for all user input occurring on the current
/// frame. This function should be called on every frame when polling /// frame. This function should be called on every frame when polling

20
ctru-rs/src/services/ps.rs
Unescape View File

@ -4,6 +4,8 @@
//! As such, it is initialized by default in `ctru::init` instead of having a safety handler //! As such, it is initialized by default in `ctru::init` instead of having a safety handler
//! See also <https://www.3dbrew.org/wiki/Process_Services> //! See also <https://www.3dbrew.org/wiki/Process_Services>
use crate::error::LibCtruError;
#[repr(u32)] #[repr(u32)]
pub enum AESAlgorithm { pub enum AESAlgorithm {
CbcEnc, CbcEnc,
@ -31,33 +33,21 @@ pub enum AESKeyType {
pub fn local_friend_code_seed() -> crate::Result<u64> { pub fn local_friend_code_seed() -> crate::Result<u64> {
let mut seed: u64 = 0; let mut seed: u64 = 0;
let r = unsafe { ctru_sys::PS_GetLocalFriendCodeSeed(&mut seed) }; LibCtruError(unsafe { ctru_sys::PS_GetLocalFriendCodeSeed(&mut seed) })?;
if r < 0 {
Err(r.into())
} else {
Ok(seed) Ok(seed)
} }
}
pub fn device_id() -> crate::Result<u32> { pub fn device_id() -> crate::Result<u32> {
let mut id: u32 = 0; let mut id: u32 = 0;
let r = unsafe { ctru_sys::PS_GetDeviceId(&mut id) }; LibCtruError(unsafe { ctru_sys::PS_GetDeviceId(&mut id) })?;
if r < 0 {
Err(r.into())
} else {
Ok(id) Ok(id)
} }
}
pub fn generate_random_bytes(out: &mut [u8]) -> crate::Result<()> { pub fn generate_random_bytes(out: &mut [u8]) -> crate::Result<()> {
let r = unsafe { ctru_sys::PS_GenerateRandomBytes(out as *mut _ as *mut _, out.len() as u32) }; LibCtruError(unsafe { ctru_sys::PS_GenerateRandomBytes(out as *mut _ as *mut _, out.len() as u32) })?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {

6
ctru-rs/src/services/soc.rs
Unescape View File

@ -5,6 +5,7 @@ use std::sync::Mutex;
use crate::services::ServiceReference; use crate::services::ServiceReference;
use crate::Error; use crate::Error;
use crate::error::LibCtruError;
/// Soc service. Initializing this service will enable the use of network sockets and utilities /// Soc service. Initializing this service will enable the use of network sockets and utilities
/// such as those found in `std::net`. The service will be closed when this struct is is dropped. /// such as those found in `std::net`. The service will be closed when this struct is is dropped.
@ -38,10 +39,7 @@ impl Soc {
false, false,
|| { || {
let soc_mem = unsafe { memalign(0x1000, num_bytes) } as *mut u32; let soc_mem = unsafe { memalign(0x1000, num_bytes) } as *mut u32;
let r = unsafe { ctru_sys::socInit(soc_mem, num_bytes as u32) }; LibCtruError(unsafe { ctru_sys::socInit(soc_mem, num_bytes as u32) })?;
if r < 0 {
return Err(r.into());
}
Ok(()) Ok(())
}, },

14
ctru-rs/src/services/sslc.rs
Unescape View File

@ -1,32 +1,26 @@
// TODO: Implement remaining functions // TODO: Implement remaining functions
use crate::error::LibCtruError;
pub struct SslC(()); pub struct SslC(());
impl SslC { impl SslC {
/// Initialize sslc /// Initialize sslc
pub fn init() -> crate::Result<Self> { pub fn init() -> crate::Result<Self> {
unsafe { unsafe {
let r = ctru_sys::sslcInit(0); LibCtruError(ctru_sys::sslcInit(0))?;
if r < 0 {
Err(r.into())
} else {
Ok(SslC(())) Ok(SslC(()))
} }
} }
}
/// Fill `buf` with `buf.len()` random bytes /// Fill `buf` with `buf.len()` random bytes
pub fn generate_random_data(&self, buf: &mut [u8]) -> crate::Result<()> { pub fn generate_random_data(&self, buf: &mut [u8]) -> crate::Result<()> {
unsafe { unsafe {
let r = ctru_sys::sslcGenerateRandomData(buf.as_ptr() as _, buf.len() as u32); LibCtruError(ctru_sys::sslcGenerateRandomData(buf.as_ptr() as _, buf.len() as u32))?;
if r < 0 {
Err(r.into())
} else {
Ok(()) Ok(())
} }
} }
} }
}
impl Drop for SslC { impl Drop for SslC {
fn drop(&mut self) { fn drop(&mut self) {

Write Preview
Loading…
Cancel
Save