@ -1,11 +1,10 @@
@@ -1,11 +1,10 @@
//! CAM service
//! Camera service
//!
//! The CAM service provides access to the cameras. Cameras can return 2D images
//! in the form of byte vectors which can be used for display or other usage s.
//! The CAM service provides access to the cameras. Cameras can return images
//! in the form of byte vectors which can be displayed or used in other way s.
use crate ::error ::ResultCode ;
use crate ::error ::{ Error , ResultCode } ;
use crate ::services ::gspgpu ::FramebufferFormat ;
use bitflags ::bitflags ;
use ctru_sys ::Handle ;
use std ::time ::Duration ;
@ -21,191 +20,169 @@ pub struct Cam {
@@ -21,191 +20,169 @@ pub struct Cam {
pub both_outer_cams : BothOutwardCam ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::flip_image]
#[ derive(Default) ]
pub struct CamFlip : u32 {
const NONE = ctru_sys ::FLIP_NONE ;
const HORIZONTAL = ctru_sys ::FLIP_HORIZONTAL ;
const VERTICAL = ctru_sys ::FLIP_VERTICAL ;
const REVERSE = ctru_sys ::FLIP_REVERSE ;
}
/// Flag to pass to [Camera::flip_image]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum FlipMode {
None = ctru_sys ::FLIP_NONE ,
Horizontal = ctru_sys ::FLIP_HORIZONTAL ,
Vertical = ctru_sys ::FLIP_VERTICAL ,
Reverse = ctru_sys ::FLIP_REVERSE ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_view_size]
#[ derive(Default) ]
pub struct CamSize : u32 {
const VGA = ctru_sys ::SIZE_VGA ;
const QVGA = ctru_sys ::SIZE_QVGA ;
const QQVGA = ctru_sys ::SIZE_QQVGA ;
const CIF = ctru_sys ::SIZE_CIF ;
const QCIF = ctru_sys ::SIZE_QCIF ;
const DS_LCD = ctru_sys ::SIZE_DS_LCD ;
const DS_LCD_X4 = ctru_sys ::SIZE_DS_LCDx4 ;
const CTR_TOP_LCD = ctru_sys ::SIZE_CTR_TOP_LCD ;
const CTR_BOTTOM_LCD = ctru_sys ::SIZE_CTR_BOTTOM_LCD ;
}
/// Flag to pass to [Camera::set_view_size]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum ViewSize {
TopLCD = ctru_sys ::SIZE_CTR_TOP_LCD ,
/// Equivalent to QVga
BottomLCD = ctru_sys ::SIZE_CTR_BOTTOM_LCD ,
Vga = ctru_sys ::SIZE_VGA ,
QQVga = ctru_sys ::SIZE_QQVGA ,
Cif = ctru_sys ::SIZE_CIF ,
QCif = ctru_sys ::SIZE_QCIF ,
/// Nintendo DS Screen
DS = ctru_sys ::SIZE_DS_LCD ,
/// Nintendo DS Screen x4
DSX4 = ctru_sys ::SIZE_DS_LCDx4 ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_frame_rate]
#[ derive(Default) ]
pub struct CamFrameRate : u32 {
const RATE_15 = ctru_sys ::FRAME_RATE_15 ;
const RATE_15_TO_5 = ctru_sys ::FRAME_RATE_15_TO_5 ;
const RATE_15_TO_2 = ctru_sys ::FRAME_RATE_15_TO_2 ;
const RATE_10 = ctru_sys ::FRAME_RATE_10 ;
const RATE_8_5 = ctru_sys ::FRAME_RATE_8_5 ;
const RATE_5 = ctru_sys ::FRAME_RATE_5 ;
const RATE_20 = ctru_sys ::FRAME_RATE_20 ;
const RATE_20_TO_5 = ctru_sys ::FRAME_RATE_20_TO_5 ;
const RATE_30 = ctru_sys ::FRAME_RATE_30 ;
const RATE_30_TO_5 = ctru_sys ::FRAME_RATE_30_TO_5 ;
const RATE_15_TO_10 = ctru_sys ::FRAME_RATE_15_TO_10 ;
const RATE_20_TO_10 = ctru_sys ::FRAME_RATE_20_TO_10 ;
const RATE_30_TO_10 = ctru_sys ::FRAME_RATE_30_TO_10 ;
}
/// Flag to pass to [Camera::set_frame_rate]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum FrameRate {
Fps15 = ctru_sys ::FRAME_RATE_15 ,
Fps15To5 = ctru_sys ::FRAME_RATE_15_TO_5 ,
Fps15To2 = ctru_sys ::FRAME_RATE_15_TO_2 ,
Fps10 = ctru_sys ::FRAME_RATE_10 ,
Fps8_5 = ctru_sys ::FRAME_RATE_8_5 ,
Fps5 = ctru_sys ::FRAME_RATE_5 ,
Fps20 = ctru_sys ::FRAME_RATE_20 ,
Fps20To5 = ctru_sys ::FRAME_RATE_20_TO_5 ,
Fps30 = ctru_sys ::FRAME_RATE_30 ,
Fps30To5 = ctru_sys ::FRAME_RATE_30_TO_5 ,
Fps15To10 = ctru_sys ::FRAME_RATE_15_TO_10 ,
Fps20To10 = ctru_sys ::FRAME_RATE_20_TO_10 ,
Fps30To10 = ctru_sys ::FRAME_RATE_30_TO_10 ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_white_balance] or
/// [Camera::set_white_balance_without_base_up]
#[ derive(Default) ]
pub struct CamWhiteBalance : u32 {
const AUTO = ctru_sys ::WHITE_BALANCE_AUTO ;
const BALANCE_3200K = ctru_sys ::WHITE_BALANCE_3200K ;
const BALANCE_4150K = ctru_sys ::WHITE_BALANCE_4150K ;
const BALANCE_5200K = ctru_sys ::WHITE_BALANCE_5200K ;
const BALANCE_6000K = ctru_sys ::WHITE_BALANCE_6000K ;
const BALANCE_7000K = ctru_sys ::WHITE_BALANCE_7000K ;
const NORMAL = ctru_sys ::WHITE_BALANCE_NORMAL ;
const TUNGSTEN = ctru_sys ::WHITE_BALANCE_TUNGSTEN ;
const WHITE_FLUORESCENT_LIGHT = ctru_sys ::WHITE_BALANCE_WHITE_FLUORESCENT_LIGHT ;
const DAYLIGHT = ctru_sys ::WHITE_BALANCE_DAYLIGHT ;
const CLOUDY = ctru_sys ::WHITE_BALANCE_CLOUDY ;
const HORIZON = ctru_sys ::WHITE_BALANCE_HORIZON ;
const SHADE = ctru_sys ::WHITE_BALANCE_SHADE ;
}
/// Flag to pass to [Camera::set_white_balance] or
/// [Camera::set_white_balance_without_base_up]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum WhiteBalance {
/// Normal
Auto = ctru_sys ::WHITE_BALANCE_AUTO ,
/// Tungsten
Temp3200K = ctru_sys ::WHITE_BALANCE_3200K ,
/// Fluorescent Light
Temp4150K = ctru_sys ::WHITE_BALANCE_4150K ,
/// Daylight
Temp5200K = ctru_sys ::WHITE_BALANCE_5200K ,
/// Cloudy/Horizon
Temp6000K = ctru_sys ::WHITE_BALANCE_6000K ,
///Shade
Temp7000K = ctru_sys ::WHITE_BALANCE_7000K ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_photo_mode]
#[ derive(Default) ]
pub struct CamPhotoMode : u32 {
const NORMAL = ctru_sys ::PHOTO_MODE_NORMAL ;
const PORTRAIT = ctru_sys ::PHOTO_MODE_PORTRAIT ;
const LANDSCAPE = ctru_sys ::PHOTO_MODE_LANDSCAPE ;
const NIGHTVIEW = ctru_sys ::PHOTO_MODE_NIGHTVIEW ;
const LETTER = ctru_sys ::PHOTO_MODE_LETTER ;
}
/// Flag to pass to [Camera::set_photo_mode]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum PhotoMode {
Normal = ctru_sys ::PHOTO_MODE_NORMAL ,
Portrait = ctru_sys ::PHOTO_MODE_PORTRAIT ,
Landscape = ctru_sys ::PHOTO_MODE_LANDSCAPE ,
NightView = ctru_sys ::PHOTO_MODE_NIGHTVIEW ,
Letter = ctru_sys ::PHOTO_MODE_LETTER ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_effect]
#[ derive(Default) ]
pub struct CamEffect : u32 {
const NONE = ctru_sys ::EFFECT_NONE ;
const MONO = ctru_sys ::EFFECT_MONO ;
const SEPIA = ctru_sys ::EFFECT_SEPIA ;
const NEGATIVE = ctru_sys ::EFFECT_NEGATIVE ;
const NEGAFILM = ctru_sys ::EFFECT_NEGAFILM ;
const SEPIA01 = ctru_sys ::EFFECT_SEPIA01 ;
}
/// Flag to pass to [Camera::set_effect]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum Effect {
None = ctru_sys ::EFFECT_NONE ,
Mono = ctru_sys ::EFFECT_MONO ,
Sepia = ctru_sys ::EFFECT_SEPIA ,
Negative = ctru_sys ::EFFECT_NEGATIVE ,
Negafilm = ctru_sys ::EFFECT_NEGAFILM ,
Sepia01 = ctru_sys ::EFFECT_SEPIA01 ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_contrast]
#[ derive(Default) ]
pub struct CamContrast : u32 {
const PATTERN_01 = ctru_sys ::CONTRAST_PATTERN_01 ;
const PATTERN_02 = ctru_sys ::CONTRAST_PATTERN_02 ;
const PATTERN_03 = ctru_sys ::CONTRAST_PATTERN_03 ;
const PATTERN_04 = ctru_sys ::CONTRAST_PATTERN_04 ;
const PATTERN_05 = ctru_sys ::CONTRAST_PATTERN_05 ;
const PATTERN_06 = ctru_sys ::CONTRAST_PATTERN_06 ;
const PATTERN_07 = ctru_sys ::CONTRAST_PATTERN_07 ;
const PATTERN_08 = ctru_sys ::CONTRAST_PATTERN_08 ;
const PATTERN_09 = ctru_sys ::CONTRAST_PATTERN_09 ;
const PATTERN_10 = ctru_sys ::CONTRAST_PATTERN_10 ;
const PATTERN_11 = ctru_sys ::CONTRAST_PATTERN_11 ;
const LOW = ctru_sys ::CONTRAST_LOW ;
const NORMAL = ctru_sys ::CONTRAST_NORMAL ;
const HIGH = ctru_sys ::CONTRAST_HIGH ;
}
/// Flag to pass to [Camera::set_contrast]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum Contrast {
/// OFF
Low = ctru_sys ::CONTRAST_LOW ,
/// Brightness ratio: 70
Normal = ctru_sys ::CONTRAST_NORMAL ,
/// Brightness ratio: 90
High = ctru_sys ::CONTRAST_HIGH ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_lens_correction]
#[ derive(Default) ]
pub struct CamLensCorrection : u32 {
const OFF = ctru_sys ::LENS_CORRECTION_OFF ;
const ON_70 = ctru_sys ::LENS_CORRECTION_ON_70 ;
const ON_90 = ctru_sys ::LENS_CORRECTION_ON_90 ;
/// Flag to pass to [Camera::set_lens_correction]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum LensCorrection {
Off = ctru_sys ::LENS_CORRECTION_DARK ,
Normal = ctru_sys ::LENS_CORRECTION_NORMAL ,
Bright = ctru_sys ::LENS_CORRECTION_BRIGHT ,
}
const DARK = ctru_sys ::LENS_CORRECTION_DARK ;
const NORMAL = ctru_sys ::LENS_CORRECTION_NORMAL ;
const BRIGHT = ctru_sys ::LENS_CORRECTION_BRIGHT ;
}
/// Flag to pass to [Camera::set_output_format]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32) ]
pub enum OutputFormat {
Yuv422 = ctru_sys ::OUTPUT_YUV_422 ,
Rgb565 = ctru_sys ::OUTPUT_RGB_565 ,
}
bitflags ! {
/// A set of flags to be passed to [Camera::set_output_format]
#[ derive(Default )]
pub struct CamOutputFormat : u32 {
const YUV_422 = ctru_sys ::OUTPUT_YUV_422 ;
const RGB_565 = ctru_sys ::OUTPUT_RGB_565 ;
}
/// Flag to pass to [Cam::play_shutter_sound]
#[ derive(Copy, Clone, Debug, PartialEq, Eq) ]
#[ repr(u32 )]
pub enum ShutterSound {
Normal = ctru_sys ::SHUTTER_SOUND_TYPE_NORMAL ,
Movie = ctru_sys ::SHUTTER_SOUND_TYPE_MOVIE ,
MovieEnd = ctru_sys ::SHUTTER_SOUND_TYPE_MOVIE_END ,
}
impl TryFrom < FramebufferFormat > for Cam OutputFormat {
impl TryFrom < FramebufferFormat > for OutputFormat {
type Error = ( ) ;
fn try_from ( value : FramebufferFormat ) -> Result < Self , Self ::Error > {
match value {
FramebufferFormat ::Rgb565 = > Ok ( CamOutputFormat ::RGB_ 565) ,
FramebufferFormat ::Rgb565 = > Ok ( OutputFormat ::Rgb 565) ,
_ = > Err ( ( ) ) ,
}
}
}
impl TryFrom < Cam OutputFormat> for FramebufferFormat {
impl TryFrom < OutputFormat > for FramebufferFormat {
type Error = ( ) ;
fn try_from ( value : Cam OutputFormat) -> Result < Self , Self ::Error > {
fn try_from ( value : OutputFormat ) -> Result < Self , Self ::Error > {
match value {
CamOutputFormat ::RGB_ 565 = > Ok ( FramebufferFormat ::Rgb565 ) ,
OutputFormat ::Rgb 565 = > Ok ( FramebufferFormat ::Rgb565 ) ,
_ = > Err ( ( ) ) ,
}
}
}
bitflags ! {
/// A set of flags to be passed to [Cam::play_shutter_sound]
#[ derive(Default) ]
pub struct CamShutterSoundType : u32 {
const NORMAL = ctru_sys ::SHUTTER_SOUND_TYPE_NORMAL ;
const MOVIE = ctru_sys ::SHUTTER_SOUND_TYPE_MOVIE ;
const MOVIE_END = ctru_sys ::SHUTTER_SOUND_TYPE_MOVIE_END ;
}
}
/// Struct containing coordinates passed to [Camera::set_trimming_params].
pub struct CamTrimmingParams {
#[ derive(Clone, Copy, Debug, PartialEq, Eq) ]
pub struct TrimmingParams {
x_start : i16 ,
y_start : i16 ,
x_end : i16 ,
y_end : i16 ,
}
impl Cam TrimmingParams {
impl TrimmingParams {
/// Creates a new [CamTrimmingParams] and guarantees the start coordinates are less than or
/// equal to the end coordinates.
///
/// `x_start <= x_end && y_start <= y_end`
pub fn new ( x_start : i16 , y_start : i16 , x_end : i16 , y_end : i16 ) -> Cam TrimmingParams {
pub fn new ( x_start : i16 , y_start : i16 , x_end : i16 , y_end : i16 ) -> TrimmingParams {
assert! ( x_start < = x_end & & y_start < = y_end ) ;
Self {
x_start ,
@ -217,11 +194,11 @@ impl CamTrimmingParams {
@@ -217,11 +194,11 @@ impl CamTrimmingParams {
}
/// Represents data used by the camera to calibrate image quality
#[ derive(Default) ]
#[ derive(Default, Clone, Copy, Debug ) ]
pub struct ImageQualityCalibrationData ( pub ctru_sys ::CAMU_ImageQualityCalibrationData ) ;
/// Represents data used by the camera to calibrate image quality when using both outward cameras
#[ derive(Default) ]
#[ derive(Default, Clone, Copy, Debug ) ]
pub struct StereoCameraCalibrationData ( pub ctru_sys ::CAMU_StereoCameraCalibrationData ) ;
/// Represents the camera on the inside of the 3DS
@ -307,7 +284,7 @@ pub trait Camera {
@@ -307,7 +284,7 @@ pub trait Camera {
/// Returns the maximum amount of transfer bytes based on the view size, trimming, and other
/// modifications set to the camera
fn get_transfer_bytes ( & self ) -> crate ::Result < u32 > {
fn transfer_byte_count ( & self ) -> crate ::Result < u32 > {
unsafe {
let mut transfer_bytes = 0 ;
ResultCode ( ctru_sys ::CAMU_GetTransferBytes (
@ -336,8 +313,8 @@ pub trait Camera {
@@ -336,8 +313,8 @@ pub trait Camera {
}
}
/// Sets trimming parameters based on coordinates specified inside a [Cam TrimmingParams]
fn set_trimming_params ( & mut self , params : Cam TrimmingParams) -> crate ::Result < ( ) > {
/// Sets trimming parameters based on coordinates specified inside a [TrimmingParams]
fn set_trimming_params ( & mut self , params : TrimmingParams ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetTrimmingParams (
self . port_as_raw ( ) ,
@ -350,8 +327,8 @@ pub trait Camera {
@@ -350,8 +327,8 @@ pub trait Camera {
}
}
/// Returns the set [CamTrimmingParams] from the camera
fn get_ trimming_params( & self ) -> crate ::Result < Cam TrimmingParams> {
/// Returns the [TrimmingParams] set
fn trimming_params ( & self ) -> crate ::Result < TrimmingParams > {
unsafe {
let mut x_start = 0 ;
let mut y_start = 0 ;
@ -365,7 +342,7 @@ pub trait Camera {
@@ -365,7 +342,7 @@ pub trait Camera {
self . port_as_raw ( ) ,
) ) ? ;
Ok ( Cam TrimmingParams {
Ok ( TrimmingParams {
x_start ,
y_start ,
x_end ,
@ -378,7 +355,7 @@ pub trait Camera {
@@ -378,7 +355,7 @@ pub trait Camera {
/// The new width will be `trim_width / 2` to the left and right of the center.
/// The new height will be `trim_height / 2` above and below the center.
fn set_trimming_params_center (
& self ,
& mut self ,
trim_width : i16 ,
trim_height : i16 ,
cam_width : i16 ,
@ -404,27 +381,27 @@ pub trait Camera {
@@ -404,27 +381,27 @@ pub trait Camera {
}
}
/// Sets the white balance mod of the camera based on the passed [Cam WhiteBalance] argument
fn set_white_balance ( & mut self , white_balance : Cam WhiteBalance) -> crate ::Result < ( ) > {
/// Sets the white balance mod of the camera based on the passed [WhiteBalance] argument
fn set_white_balance ( & mut self , white_balance : WhiteBalance ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetWhiteBalance (
self . camera_as_raw ( ) ,
white_balance . bits ( ) ,
white_balance . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the white balance mode of the camera based on the passed [Cam WhiteBalance] argument
/// Sets the white balance mode of the camera based on the passed [WhiteBalance] argument
// TODO: Explain base up
fn set_white_balance_without_base_up (
& mut self ,
white_balance : Cam WhiteBalance,
white_balance : WhiteBalance ,
) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetWhiteBalanceWithoutBaseUp (
self . camera_as_raw ( ) ,
white_balance . bits ( ) ,
white_balance . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
@ -484,12 +461,12 @@ pub trait Camera {
@@ -484,12 +461,12 @@ pub trait Camera {
}
}
/// Sets the flip direction of the camera's image based on the passed [Cam Flip] argument
fn flip_image ( & mut self , flip : Cam Flip) -> crate ::Result < ( ) > {
/// Sets the flip direction of the camera's image based on the passed [FlipMode ] argument
fn flip_image ( & mut self , flip : FlipMode ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_FlipImage (
self . camera_as_raw ( ) ,
flip . bits ( ) ,
flip . into ( ) ,
ctru_sys ::CONTEXT_A ,
) ) ? ;
Ok ( ( ) )
@ -530,82 +507,82 @@ pub trait Camera {
@@ -530,82 +507,82 @@ pub trait Camera {
}
}
/// Sets the view size of the camera based on the passed [Cam Size] argument.
fn set_view_size ( & mut self , size : Cam Size) -> crate ::Result < ( ) > {
/// Sets the view size of the camera based on the passed [View Size] argument.
fn set_view_size ( & mut self , size : View Size) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetSize (
self . camera_as_raw ( ) ,
size . bits ( ) ,
size . into ( ) ,
ctru_sys ::CONTEXT_A ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the frame rate of the camera based on the passed [Cam FrameRate] argument.
fn set_frame_rate ( & mut self , frame_rate : Cam FrameRate) -> crate ::Result < ( ) > {
/// Sets the frame rate of the camera based on the passed [FrameRate] argument.
fn set_frame_rate ( & mut self , frame_rate : FrameRate ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetFrameRate (
self . camera_as_raw ( ) ,
frame_rate . bits ( ) ,
frame_rate . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the photo mode of the camera based on the passed [Cam PhotoMode] argument.
fn set_photo_mode ( & mut self , photo_mode : Cam PhotoMode) -> crate ::Result < ( ) > {
/// Sets the photo mode of the camera based on the passed [PhotoMode] argument.
fn set_photo_mode ( & mut self , photo_mode : PhotoMode ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetPhotoMode (
self . camera_as_raw ( ) ,
photo_mode . bits ( ) ,
photo_mode . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the effect of the camera based on the passed [Cam Effect] argument.
/// Sets the effect of the camera based on the passed [Effect] argument.
///
/// Multiple effects can be set at once by combining the bitflags of [CamEffect]
fn set_effect ( & mut self , effect : Cam Effect) -> crate ::Result < ( ) > {
fn set_effect ( & mut self , effect : Effect ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetEffect (
self . camera_as_raw ( ) ,
effect . bits ( ) ,
effect . into ( ) ,
ctru_sys ::CONTEXT_A ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the contrast of the camera based on the passed [CamC ontrast] argument.
fn set_contrast ( & mut self , contrast : CamC ontrast ) -> crate ::Result < ( ) > {
/// Sets the contrast of the camera based on the passed [Contrast] argument.
fn set_contrast ( & mut self , contrast : Contrast ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetContrast (
self . camera_as_raw ( ) ,
contrast . bits ( ) ,
contrast . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the lens correction of the camera based on the passed [Cam LensCorrection] argument.
fn set_lens_correction ( & mut self , lens_correction : Cam LensCorrection) -> crate ::Result < ( ) > {
/// Sets the lens correction of the camera based on the passed [LensCorrection] argument.
fn set_lens_correction ( & mut self , lens_correction : LensCorrection ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetLensCorrection (
self . camera_as_raw ( ) ,
lens_correction . bits ( ) ,
lens_correction . into ( ) ,
) ) ? ;
Ok ( ( ) )
}
}
/// Sets the output format of the camera based on the passed [Cam OutputFormat] argument.
fn set_output_format ( & mut self , format : Cam OutputFormat) -> crate ::Result < ( ) > {
/// Sets the output format of the camera based on the passed [OutputFormat] argument.
fn set_output_format ( & mut self , format : OutputFormat ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_SetOutputFormat (
self . camera_as_raw ( ) ,
format . bits ( ) ,
format . into ( ) ,
ctru_sys ::CONTEXT_A ,
) ) ? ;
Ok ( ( ) )
@ -687,7 +664,7 @@ pub trait Camera {
@@ -687,7 +664,7 @@ pub trait Camera {
}
/// Returns the current [ImageQualityCalibrationData] for the camera
fn get_ image_quality_calibration_data( & self ) -> crate ::Result < ImageQualityCalibrationData > {
fn image_quality_calibration_data ( & self ) -> crate ::Result < ImageQualityCalibrationData > {
unsafe {
let mut data = ImageQualityCalibrationData ::default ( ) ;
ResultCode ( ctru_sys ::CAMU_GetImageQualityCalibrationData ( & mut data . 0 ) ) ? ;
@ -704,7 +681,7 @@ pub trait Camera {
@@ -704,7 +681,7 @@ pub trait Camera {
}
}
/// Requests the camera to take a picture and returns a vector containing the image bytes .
/// Requests the camera to take a picture and write it in a buffer .
///
/// # Errors
///
@ -717,10 +694,11 @@ pub trait Camera {
@@ -717,10 +694,11 @@ pub trait Camera {
/// * `timeout` - Duration to wait for the image
fn take_picture (
& mut self ,
buffer : & mut [ u8 ] ,
width : u16 ,
height : u16 ,
timeout : Duration ,
) -> crate ::Result < Vec < u8 > > {
) -> crate ::Result < ( ) > {
let transfer_unit = unsafe {
let mut buf_size = 0 ;
ResultCode ( ctru_sys ::CAMU_GetMaxBytes (
@ -731,10 +709,6 @@ pub trait Camera {
@@ -731,10 +709,6 @@ pub trait Camera {
Ok ::< u32 , i32 > ( buf_size )
} ? ;
let screen_size = u32 ::from ( width ) * u32 ::from ( width ) * 2 ;
let mut buf = vec! [ 0 u8 ; usize ::try_from ( screen_size ) . unwrap ( ) ] ;
unsafe {
ResultCode ( ctru_sys ::CAMU_SetTransferBytes (
self . port_as_raw ( ) ,
@ -744,6 +718,14 @@ pub trait Camera {
@@ -744,6 +718,14 @@ pub trait Camera {
) ) ? ;
} ;
let screen_size : usize = usize ::from ( width ) * usize ::from ( height ) * 2 ;
if buffer . len ( ) < screen_size {
return Err ( Error ::BufferTooShort {
provided : buffer . len ( ) ,
wanted : screen_size ,
} ) ;
}
unsafe {
ResultCode ( ctru_sys ::CAMU_Activate ( self . camera_as_raw ( ) ) ) ? ;
ResultCode ( ctru_sys ::CAMU_ClearBuffer ( self . port_as_raw ( ) ) ) ? ;
@ -754,25 +736,30 @@ pub trait Camera {
@@ -754,25 +736,30 @@ pub trait Camera {
let mut completion_handle : Handle = 0 ;
ResultCode ( ctru_sys ::CAMU_SetReceiving (
& mut completion_handle ,
buf . as_mut_ptr ( ) as * mut ::libc ::c_void ,
buffer . as_mut_ptr ( ) . cast ( ) ,
self . port_as_raw ( ) ,
screen_size ,
screen_size as u32 ,
transfer_unit . try_into ( ) . unwrap ( ) ,
) ) ? ;
Ok ::< Handle , i32 > ( completion_handle )
} ? ;
unsafe {
ResultCode ( ctru_sys ::svcWaitSynchronization (
// Panicking without closing an SVC handle causes an ARM exception, we have to handle it carefully (TODO: SVC module)
let wait_result = ResultCode ( ctru_sys ::svcWaitSynchronization (
receive_event ,
timeout . as_nanos ( ) . try_into ( ) . unwrap ( ) ,
) ) ? ;
) ) ;
// We close everything first, then we check for possible errors
let _ = ctru_sys ::svcCloseHandle ( receive_event ) ; // We wouldn't return the error even if there was one, so no use of ResultCode is needed
ResultCode ( ctru_sys ::CAMU_StopCapture ( self . port_as_raw ( ) ) ) ? ;
ResultCode ( ctru_sys ::svcCloseHandle ( receive_event ) ) ? ;
ResultCode ( ctru_sys ::CAMU_Activate ( ctru_sys ::SELECT_NONE ) ) ? ;
wait_result ? ;
} ;
Ok ( buf )
Ok ( ( ) )
}
}
@ -784,7 +771,7 @@ impl Cam {
@@ -784,7 +771,7 @@ impl Cam {
/// This function will return an error if the service was unable to be initialized.
/// Since this service requires no special or elevated permissions, errors are
/// rare in practice.
pub fn init ( ) -> crate ::Result < Cam > {
pub fn new ( ) -> crate ::Result < Cam > {
unsafe {
ResultCode ( ctru_sys ::camInit ( ) ) ? ;
Ok ( Cam {
@ -796,10 +783,10 @@ impl Cam {
@@ -796,10 +783,10 @@ impl Cam {
}
}
/// Plays the specified sound based on the [Cam ShutterSoundType ] argument
pub fn play_shutter_sound ( & self , sound : Cam ShutterSoundType ) -> crate ::Result < ( ) > {
/// Plays the specified sound based on the [ShutterSound] argument
pub fn play_shutter_sound ( & self , sound : ShutterSound ) -> crate ::Result < ( ) > {
unsafe {
ResultCode ( ctru_sys ::CAMU_PlayShutterSound ( sound . bits ( ) ) ) ? ;
ResultCode ( ctru_sys ::CAMU_PlayShutterSound ( sound . into ( ) ) ) ? ;
Ok ( ( ) )
}
}
@ -810,3 +797,14 @@ impl Drop for Cam {
@@ -810,3 +797,14 @@ impl Drop for Cam {
unsafe { ctru_sys ::camExit ( ) } ;
}
}
from_impl ! ( FlipMode , ctru_sys ::CAMU_Flip ) ;
from_impl ! ( ViewSize , ctru_sys ::CAMU_Size ) ;
from_impl ! ( FrameRate , ctru_sys ::CAMU_FrameRate ) ;
from_impl ! ( WhiteBalance , ctru_sys ::CAMU_WhiteBalance ) ;
from_impl ! ( PhotoMode , ctru_sys ::CAMU_PhotoMode ) ;
from_impl ! ( Effect , ctru_sys ::CAMU_Effect ) ;
from_impl ! ( Contrast , ctru_sys ::CAMU_Contrast ) ;
from_impl ! ( LensCorrection , ctru_sys ::CAMU_LensCorrection ) ;
from_impl ! ( OutputFormat , ctru_sys ::CAMU_OutputFormat ) ;
from_impl ! ( ShutterSound , ctru_sys ::CAMU_ShutterSoundType ) ;
AzureMarker
2 years ago