Browse Source
Merge pull request #8484 from german77/irs_release
Merge pull request #8484 from german77/irs_release
service: irs: Add camera support, split processors and implement ImageTransferProcessornce_cpp
liamwhite
4 years ago
committed by
GitHub
GitHub
50 changed files with 2342 additions and 320 deletions
-
6CMakeLists.txt
-
8CMakeModules/CopyYuzuQt5Deps.cmake
-
29src/common/input.h
-
3src/common/settings.h
-
15src/core/CMakeLists.txt
-
59src/core/hid/emulated_controller.cpp
-
40src/core/hid/emulated_controller.h
-
14src/core/hid/input_converter.cpp
-
8src/core/hid/input_converter.h
-
301src/core/hid/irs_types.h
-
7src/core/hle/service/hid/errors.h
-
4src/core/hle/service/hid/hid.cpp
-
324src/core/hle/service/hid/irs.cpp
-
295src/core/hle/service/hid/irs.h
-
34src/core/hle/service/hid/irsensor/clustering_processor.cpp
-
74src/core/hle/service/hid/irsensor/clustering_processor.h
-
150src/core/hle/service/hid/irsensor/image_transfer_processor.cpp
-
73src/core/hle/service/hid/irsensor/image_transfer_processor.h
-
27src/core/hle/service/hid/irsensor/ir_led_processor.cpp
-
47src/core/hle/service/hid/irsensor/ir_led_processor.h
-
34src/core/hle/service/hid/irsensor/moment_processor.cpp
-
61src/core/hle/service/hid/irsensor/moment_processor.h
-
26src/core/hle/service/hid/irsensor/pointing_processor.cpp
-
61src/core/hle/service/hid/irsensor/pointing_processor.h
-
67src/core/hle/service/hid/irsensor/processor_base.cpp
-
33src/core/hle/service/hid/irsensor/processor_base.h
-
29src/core/hle/service/hid/irsensor/tera_plugin_processor.cpp
-
53src/core/hle/service/hid/irsensor/tera_plugin_processor.h
-
2src/input_common/CMakeLists.txt
-
82src/input_common/drivers/camera.cpp
-
29src/input_common/drivers/camera.h
-
38src/input_common/input_engine.cpp
-
19src/input_common/input_engine.h
-
60src/input_common/input_poller.cpp
-
11src/input_common/input_poller.h
-
21src/input_common/main.cpp
-
9src/input_common/main.h
-
5src/yuzu/CMakeLists.txt
-
82src/yuzu/bootmanager.cpp
-
14src/yuzu/bootmanager.h
-
12src/yuzu/configuration/config.cpp
-
2src/yuzu/configuration/config.h
-
138src/yuzu/configuration/configure_camera.cpp
-
54src/yuzu/configuration/configure_camera.h
-
170src/yuzu/configuration/configure_camera.ui
-
5src/yuzu/configuration/configure_input.cpp
-
3src/yuzu/configuration/configure_input_advanced.cpp
-
1src/yuzu/configuration/configure_input_advanced.h
-
14src/yuzu/configuration/configure_input_advanced.ui
-
9src/yuzu/main.cpp
@ -0,0 +1,301 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/common_funcs.h" |
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/hid_types.h" |
||||
|
|
||||
|
namespace Core::IrSensor { |
||||
|
|
||||
|
// This is nn::irsensor::CameraAmbientNoiseLevel |
||||
|
enum class CameraAmbientNoiseLevel : u32 { |
||||
|
Low, |
||||
|
Medium, |
||||
|
High, |
||||
|
Unkown3, // This level can't be reached |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::CameraLightTarget |
||||
|
enum class CameraLightTarget : u32 { |
||||
|
AllLeds, |
||||
|
BrightLeds, |
||||
|
DimLeds, |
||||
|
None, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::PackedCameraLightTarget |
||||
|
enum class PackedCameraLightTarget : u8 { |
||||
|
AllLeds, |
||||
|
BrightLeds, |
||||
|
DimLeds, |
||||
|
None, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::AdaptiveClusteringMode |
||||
|
enum class AdaptiveClusteringMode : u32 { |
||||
|
StaticFov, |
||||
|
DynamicFov, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::AdaptiveClusteringTargetDistance |
||||
|
enum class AdaptiveClusteringTargetDistance : u32 { |
||||
|
Near, |
||||
|
Middle, |
||||
|
Far, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::ImageTransferProcessorFormat |
||||
|
enum class ImageTransferProcessorFormat : u32 { |
||||
|
Size320x240, |
||||
|
Size160x120, |
||||
|
Size80x60, |
||||
|
Size40x30, |
||||
|
Size20x15, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::PackedImageTransferProcessorFormat |
||||
|
enum class PackedImageTransferProcessorFormat : u8 { |
||||
|
Size320x240, |
||||
|
Size160x120, |
||||
|
Size80x60, |
||||
|
Size40x30, |
||||
|
Size20x15, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::IrCameraStatus |
||||
|
enum class IrCameraStatus : u32 { |
||||
|
Available, |
||||
|
Unsupported, |
||||
|
Unconnected, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::IrCameraInternalStatus |
||||
|
enum class IrCameraInternalStatus : u32 { |
||||
|
Stopped, |
||||
|
FirmwareUpdateNeeded, |
||||
|
Unkown2, |
||||
|
Unkown3, |
||||
|
Unkown4, |
||||
|
FirmwareVersionRequested, |
||||
|
FirmwareVersionIsInvalid, |
||||
|
Ready, |
||||
|
Setting, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::detail::StatusManager::IrSensorMode |
||||
|
enum class IrSensorMode : u64 { |
||||
|
None, |
||||
|
MomentProcessor, |
||||
|
ClusteringProcessor, |
||||
|
ImageTransferProcessor, |
||||
|
PointingProcessorMarker, |
||||
|
TeraPluginProcessor, |
||||
|
IrLedProcessor, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::ImageProcessorStatus |
||||
|
enum ImageProcessorStatus : u32 { |
||||
|
Stopped, |
||||
|
Running, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::HandAnalysisMode |
||||
|
enum class HandAnalysisMode : u32 { |
||||
|
None, |
||||
|
Silhouette, |
||||
|
Image, |
||||
|
SilhoueteAndImage, |
||||
|
SilhuetteOnly, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::IrSensorFunctionLevel |
||||
|
enum class IrSensorFunctionLevel : u8 { |
||||
|
unknown0, |
||||
|
unknown1, |
||||
|
unknown2, |
||||
|
unknown3, |
||||
|
unknown4, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::MomentProcessorPreprocess |
||||
|
enum class MomentProcessorPreprocess : u32 { |
||||
|
Unkown0, |
||||
|
Unkown1, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::PackedMomentProcessorPreprocess |
||||
|
enum class PackedMomentProcessorPreprocess : u8 { |
||||
|
Unkown0, |
||||
|
Unkown1, |
||||
|
}; |
||||
|
|
||||
|
// This is nn::irsensor::PointingStatus |
||||
|
enum class PointingStatus : u32 { |
||||
|
Unkown0, |
||||
|
Unkown1, |
||||
|
}; |
||||
|
|
||||
|
struct IrsRect { |
||||
|
s16 x; |
||||
|
s16 y; |
||||
|
s16 width; |
||||
|
s16 height; |
||||
|
}; |
||||
|
|
||||
|
struct IrsCentroid { |
||||
|
f32 x; |
||||
|
f32 y; |
||||
|
}; |
||||
|
|
||||
|
struct CameraConfig { |
||||
|
u64 exposure_time; |
||||
|
CameraLightTarget light_target; |
||||
|
u32 gain; |
||||
|
bool is_negative_used; |
||||
|
INSERT_PADDING_BYTES(7); |
||||
|
}; |
||||
|
static_assert(sizeof(CameraConfig) == 0x18, "CameraConfig is an invalid size"); |
||||
|
|
||||
|
struct PackedCameraConfig { |
||||
|
u64 exposure_time; |
||||
|
PackedCameraLightTarget light_target; |
||||
|
u8 gain; |
||||
|
bool is_negative_used; |
||||
|
INSERT_PADDING_BYTES(5); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedCameraConfig) == 0x10, "PackedCameraConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::IrCameraHandle |
||||
|
struct IrCameraHandle { |
||||
|
u8 npad_id{}; |
||||
|
Core::HID::NpadStyleIndex npad_type{Core::HID::NpadStyleIndex::None}; |
||||
|
INSERT_PADDING_BYTES(2); |
||||
|
}; |
||||
|
static_assert(sizeof(IrCameraHandle) == 4, "IrCameraHandle is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedMcuVersion |
||||
|
struct PackedMcuVersion { |
||||
|
u16 major; |
||||
|
u16 minor; |
||||
|
}; |
||||
|
static_assert(sizeof(PackedMcuVersion) == 4, "PackedMcuVersion is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedMomentProcessorConfig |
||||
|
struct PackedMomentProcessorConfig { |
||||
|
PackedCameraConfig camera_config; |
||||
|
IrsRect window_of_interest; |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
PackedMomentProcessorPreprocess preprocess; |
||||
|
u8 preprocess_intensity_threshold; |
||||
|
INSERT_PADDING_BYTES(2); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedMomentProcessorConfig) == 0x20, |
||||
|
"PackedMomentProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedClusteringProcessorConfig |
||||
|
struct PackedClusteringProcessorConfig { |
||||
|
PackedCameraConfig camera_config; |
||||
|
IrsRect window_of_interest; |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
u32 pixel_count_min; |
||||
|
u32 pixel_count_max; |
||||
|
u8 object_intensity_min; |
||||
|
bool is_external_light_filter_enabled; |
||||
|
INSERT_PADDING_BYTES(2); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedClusteringProcessorConfig) == 0x28, |
||||
|
"PackedClusteringProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedImageTransferProcessorConfig |
||||
|
struct PackedImageTransferProcessorConfig { |
||||
|
PackedCameraConfig camera_config; |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
PackedImageTransferProcessorFormat format; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedImageTransferProcessorConfig) == 0x18, |
||||
|
"PackedImageTransferProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedTeraPluginProcessorConfig |
||||
|
struct PackedTeraPluginProcessorConfig { |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
u8 mode; |
||||
|
u8 unknown_1; |
||||
|
u8 unknown_2; |
||||
|
u8 unknown_3; |
||||
|
}; |
||||
|
static_assert(sizeof(PackedTeraPluginProcessorConfig) == 0x8, |
||||
|
"PackedTeraPluginProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedPointingProcessorConfig |
||||
|
struct PackedPointingProcessorConfig { |
||||
|
IrsRect window_of_interest; |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
}; |
||||
|
static_assert(sizeof(PackedPointingProcessorConfig) == 0xC, |
||||
|
"PackedPointingProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedFunctionLevel |
||||
|
struct PackedFunctionLevel { |
||||
|
IrSensorFunctionLevel function_level; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedFunctionLevel) == 0x4, "PackedFunctionLevel is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedImageTransferProcessorExConfig |
||||
|
struct PackedImageTransferProcessorExConfig { |
||||
|
PackedCameraConfig camera_config; |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
PackedImageTransferProcessorFormat origin_format; |
||||
|
PackedImageTransferProcessorFormat trimming_format; |
||||
|
u16 trimming_start_x; |
||||
|
u16 trimming_start_y; |
||||
|
bool is_external_light_filter_enabled; |
||||
|
INSERT_PADDING_BYTES(5); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedImageTransferProcessorExConfig) == 0x20, |
||||
|
"PackedImageTransferProcessorExConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::PackedIrLedProcessorConfig |
||||
|
struct PackedIrLedProcessorConfig { |
||||
|
PackedMcuVersion required_mcu_version; |
||||
|
u8 light_target; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
}; |
||||
|
static_assert(sizeof(PackedIrLedProcessorConfig) == 0x8, |
||||
|
"PackedIrLedProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::HandAnalysisConfig |
||||
|
struct HandAnalysisConfig { |
||||
|
HandAnalysisMode mode; |
||||
|
}; |
||||
|
static_assert(sizeof(HandAnalysisConfig) == 0x4, "HandAnalysisConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::detail::ProcessorState contents are different for each processor |
||||
|
struct ProcessorState { |
||||
|
std::array<u8, 0xE20> processor_raw_data{}; |
||||
|
}; |
||||
|
static_assert(sizeof(ProcessorState) == 0xE20, "ProcessorState is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::detail::DeviceFormat |
||||
|
struct DeviceFormat { |
||||
|
Core::IrSensor::IrCameraStatus camera_status{Core::IrSensor::IrCameraStatus::Unconnected}; |
||||
|
Core::IrSensor::IrCameraInternalStatus camera_internal_status{ |
||||
|
Core::IrSensor::IrCameraInternalStatus::Ready}; |
||||
|
Core::IrSensor::IrSensorMode mode{Core::IrSensor::IrSensorMode::None}; |
||||
|
ProcessorState state{}; |
||||
|
}; |
||||
|
static_assert(sizeof(DeviceFormat) == 0xE30, "DeviceFormat is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::ImageTransferProcessorState |
||||
|
struct ImageTransferProcessorState { |
||||
|
u64 sampling_number; |
||||
|
Core::IrSensor::CameraAmbientNoiseLevel ambient_noise_level; |
||||
|
INSERT_PADDING_BYTES(4); |
||||
|
}; |
||||
|
static_assert(sizeof(ImageTransferProcessorState) == 0x10, |
||||
|
"ImageTransferProcessorState is an invalid size"); |
||||
|
|
||||
|
} // namespace Core::IrSensor |
||||
@ -0,0 +1,34 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/clustering_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
ClusteringProcessor::ClusteringProcessor(Core::IrSensor::DeviceFormat& device_format) |
||||
|
: device(device_format) { |
||||
|
device.mode = Core::IrSensor::IrSensorMode::ClusteringProcessor; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
ClusteringProcessor::~ClusteringProcessor() = default; |
||||
|
|
||||
|
void ClusteringProcessor::StartProcessor() {} |
||||
|
|
||||
|
void ClusteringProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void ClusteringProcessor::StopProcessor() {} |
||||
|
|
||||
|
void ClusteringProcessor::SetConfig(Core::IrSensor::PackedClusteringProcessorConfig config) { |
||||
|
current_config.camera_config.exposure_time = config.camera_config.exposure_time; |
||||
|
current_config.camera_config.gain = config.camera_config.gain; |
||||
|
current_config.camera_config.is_negative_used = config.camera_config.is_negative_used; |
||||
|
current_config.camera_config.light_target = |
||||
|
static_cast<Core::IrSensor::CameraLightTarget>(config.camera_config.light_target); |
||||
|
current_config.pixel_count_min = config.pixel_count_min; |
||||
|
current_config.pixel_count_max = config.pixel_count_max; |
||||
|
current_config.is_external_light_filter_enabled = config.is_external_light_filter_enabled; |
||||
|
current_config.object_intensity_min = config.object_intensity_min; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,74 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class ClusteringProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit ClusteringProcessor(Core::IrSensor::DeviceFormat& device_format); |
||||
|
~ClusteringProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedClusteringProcessorConfig config); |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::ClusteringProcessorConfig |
||||
|
struct ClusteringProcessorConfig { |
||||
|
Core::IrSensor::CameraConfig camera_config; |
||||
|
Core::IrSensor::IrsRect window_of_interest; |
||||
|
u32 pixel_count_min; |
||||
|
u32 pixel_count_max; |
||||
|
u32 object_intensity_min; |
||||
|
bool is_external_light_filter_enabled; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
}; |
||||
|
static_assert(sizeof(ClusteringProcessorConfig) == 0x30, |
||||
|
"ClusteringProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::AdaptiveClusteringProcessorConfig |
||||
|
struct AdaptiveClusteringProcessorConfig { |
||||
|
Core::IrSensor::AdaptiveClusteringMode mode; |
||||
|
Core::IrSensor::AdaptiveClusteringTargetDistance target_distance; |
||||
|
}; |
||||
|
static_assert(sizeof(AdaptiveClusteringProcessorConfig) == 0x8, |
||||
|
"AdaptiveClusteringProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::ClusteringData |
||||
|
struct ClusteringData { |
||||
|
f32 average_intensity; |
||||
|
Core::IrSensor::IrsCentroid centroid; |
||||
|
u32 pixel_count; |
||||
|
Core::IrSensor::IrsRect bound; |
||||
|
}; |
||||
|
static_assert(sizeof(ClusteringData) == 0x18, "ClusteringData is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::ClusteringProcessorState |
||||
|
struct ClusteringProcessorState { |
||||
|
s64 sampling_number; |
||||
|
u64 timestamp; |
||||
|
u8 object_count; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
Core::IrSensor::CameraAmbientNoiseLevel ambient_noise_level; |
||||
|
std::array<ClusteringData, 0x10> data; |
||||
|
}; |
||||
|
static_assert(sizeof(ClusteringProcessorState) == 0x198, |
||||
|
"ClusteringProcessorState is an invalid size"); |
||||
|
|
||||
|
ClusteringProcessorConfig current_config{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
}; |
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,150 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hid/emulated_controller.h"
|
||||
|
#include "core/hid/hid_core.h"
|
||||
|
#include "core/hle/service/hid/irsensor/image_transfer_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
ImageTransferProcessor::ImageTransferProcessor(Core::HID::HIDCore& hid_core_, |
||||
|
Core::IrSensor::DeviceFormat& device_format, |
||||
|
std::size_t npad_index) |
||||
|
: device{device_format} { |
||||
|
npad_device = hid_core_.GetEmulatedControllerByIndex(npad_index); |
||||
|
|
||||
|
Core::HID::ControllerUpdateCallback engine_callback{ |
||||
|
.on_change = [this](Core::HID::ControllerTriggerType type) { OnControllerUpdate(type); }, |
||||
|
.is_npad_service = true, |
||||
|
}; |
||||
|
callback_key = npad_device->SetCallback(engine_callback); |
||||
|
|
||||
|
device.mode = Core::IrSensor::IrSensorMode::ImageTransferProcessor; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
ImageTransferProcessor::~ImageTransferProcessor() { |
||||
|
npad_device->DeleteCallback(callback_key); |
||||
|
}; |
||||
|
|
||||
|
void ImageTransferProcessor::StartProcessor() { |
||||
|
is_active = true; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Available; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Ready; |
||||
|
processor_state.sampling_number = 0; |
||||
|
processor_state.ambient_noise_level = Core::IrSensor::CameraAmbientNoiseLevel::Low; |
||||
|
} |
||||
|
|
||||
|
void ImageTransferProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void ImageTransferProcessor::StopProcessor() {} |
||||
|
|
||||
|
void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType type) { |
||||
|
if (type != Core::HID::ControllerTriggerType::IrSensor) { |
||||
|
return; |
||||
|
} |
||||
|
if (!is_transfer_memory_set) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
const auto camera_data = npad_device->GetCamera(); |
||||
|
|
||||
|
// This indicates how much ambient light is precent
|
||||
|
processor_state.ambient_noise_level = Core::IrSensor::CameraAmbientNoiseLevel::Low; |
||||
|
processor_state.sampling_number = camera_data.sample; |
||||
|
|
||||
|
if (camera_data.format != current_config.origin_format) { |
||||
|
LOG_WARNING(Service_IRS, "Wrong Input format {} expected {}", camera_data.format, |
||||
|
current_config.origin_format); |
||||
|
memset(transfer_memory, 0, GetDataSize(current_config.trimming_format)); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (current_config.origin_format > current_config.trimming_format) { |
||||
|
LOG_WARNING(Service_IRS, "Origin format {} is smaller than trimming format {}", |
||||
|
current_config.origin_format, current_config.trimming_format); |
||||
|
memset(transfer_memory, 0, GetDataSize(current_config.trimming_format)); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
std::vector<u8> window_data{}; |
||||
|
const auto origin_width = GetDataWidth(current_config.origin_format); |
||||
|
const auto origin_height = GetDataHeight(current_config.origin_format); |
||||
|
const auto trimming_width = GetDataWidth(current_config.trimming_format); |
||||
|
const auto trimming_height = GetDataHeight(current_config.trimming_format); |
||||
|
window_data.resize(GetDataSize(current_config.trimming_format)); |
||||
|
|
||||
|
if (trimming_width + current_config.trimming_start_x > origin_width || |
||||
|
trimming_height + current_config.trimming_start_y > origin_height) { |
||||
|
LOG_WARNING(Service_IRS, |
||||
|
"Trimming area ({}, {}, {}, {}) is outside of origin area ({}, {})", |
||||
|
current_config.trimming_start_x, current_config.trimming_start_y, |
||||
|
trimming_width, trimming_height, origin_width, origin_height); |
||||
|
memset(transfer_memory, 0, GetDataSize(current_config.trimming_format)); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
for (std::size_t y = 0; y < trimming_height; y++) { |
||||
|
for (std::size_t x = 0; x < trimming_width; x++) { |
||||
|
const std::size_t window_index = (y * trimming_width) + x; |
||||
|
const std::size_t origin_index = |
||||
|
((y + current_config.trimming_start_y) * origin_width) + x + |
||||
|
current_config.trimming_start_x; |
||||
|
window_data[window_index] = camera_data.data[origin_index]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
memcpy(transfer_memory, window_data.data(), GetDataSize(current_config.trimming_format)); |
||||
|
|
||||
|
if (!IsProcessorActive()) { |
||||
|
StartProcessor(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void ImageTransferProcessor::SetConfig(Core::IrSensor::PackedImageTransferProcessorConfig config) { |
||||
|
current_config.camera_config.exposure_time = config.camera_config.exposure_time; |
||||
|
current_config.camera_config.gain = config.camera_config.gain; |
||||
|
current_config.camera_config.is_negative_used = config.camera_config.is_negative_used; |
||||
|
current_config.camera_config.light_target = |
||||
|
static_cast<Core::IrSensor::CameraLightTarget>(config.camera_config.light_target); |
||||
|
current_config.origin_format = |
||||
|
static_cast<Core::IrSensor::ImageTransferProcessorFormat>(config.format); |
||||
|
current_config.trimming_format = |
||||
|
static_cast<Core::IrSensor::ImageTransferProcessorFormat>(config.format); |
||||
|
current_config.trimming_start_x = 0; |
||||
|
current_config.trimming_start_y = 0; |
||||
|
|
||||
|
npad_device->SetCameraFormat(current_config.origin_format); |
||||
|
} |
||||
|
|
||||
|
void ImageTransferProcessor::SetConfig( |
||||
|
Core::IrSensor::PackedImageTransferProcessorExConfig config) { |
||||
|
current_config.camera_config.exposure_time = config.camera_config.exposure_time; |
||||
|
current_config.camera_config.gain = config.camera_config.gain; |
||||
|
current_config.camera_config.is_negative_used = config.camera_config.is_negative_used; |
||||
|
current_config.camera_config.light_target = |
||||
|
static_cast<Core::IrSensor::CameraLightTarget>(config.camera_config.light_target); |
||||
|
current_config.origin_format = |
||||
|
static_cast<Core::IrSensor::ImageTransferProcessorFormat>(config.origin_format); |
||||
|
current_config.trimming_format = |
||||
|
static_cast<Core::IrSensor::ImageTransferProcessorFormat>(config.trimming_format); |
||||
|
current_config.trimming_start_x = config.trimming_start_x; |
||||
|
current_config.trimming_start_y = config.trimming_start_y; |
||||
|
|
||||
|
npad_device->SetCameraFormat(current_config.origin_format); |
||||
|
} |
||||
|
|
||||
|
void ImageTransferProcessor::SetTransferMemoryPointer(u8* t_mem) { |
||||
|
is_transfer_memory_set = true; |
||||
|
transfer_memory = t_mem; |
||||
|
} |
||||
|
|
||||
|
Core::IrSensor::ImageTransferProcessorState ImageTransferProcessor::GetState( |
||||
|
std::vector<u8>& data) const { |
||||
|
const auto size = GetDataSize(current_config.trimming_format); |
||||
|
data.resize(size); |
||||
|
memcpy(data.data(), transfer_memory, size); |
||||
|
return processor_state; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,73 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Core::HID { |
||||
|
class EmulatedController; |
||||
|
} // namespace Core::HID |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class ImageTransferProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit ImageTransferProcessor(Core::HID::HIDCore& hid_core_, |
||||
|
Core::IrSensor::DeviceFormat& device_format, |
||||
|
std::size_t npad_index); |
||||
|
~ImageTransferProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedImageTransferProcessorConfig config); |
||||
|
void SetConfig(Core::IrSensor::PackedImageTransferProcessorExConfig config); |
||||
|
|
||||
|
// Transfer memory where the image data will be stored |
||||
|
void SetTransferMemoryPointer(u8* t_mem); |
||||
|
|
||||
|
Core::IrSensor::ImageTransferProcessorState GetState(std::vector<u8>& data) const; |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::ImageTransferProcessorConfig |
||||
|
struct ImageTransferProcessorConfig { |
||||
|
Core::IrSensor::CameraConfig camera_config; |
||||
|
Core::IrSensor::ImageTransferProcessorFormat format; |
||||
|
}; |
||||
|
static_assert(sizeof(ImageTransferProcessorConfig) == 0x20, |
||||
|
"ImageTransferProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::ImageTransferProcessorExConfig |
||||
|
struct ImageTransferProcessorExConfig { |
||||
|
Core::IrSensor::CameraConfig camera_config; |
||||
|
Core::IrSensor::ImageTransferProcessorFormat origin_format; |
||||
|
Core::IrSensor::ImageTransferProcessorFormat trimming_format; |
||||
|
u16 trimming_start_x; |
||||
|
u16 trimming_start_y; |
||||
|
bool is_external_light_filter_enabled; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
}; |
||||
|
static_assert(sizeof(ImageTransferProcessorExConfig) == 0x28, |
||||
|
"ImageTransferProcessorExConfig is an invalid size"); |
||||
|
|
||||
|
void OnControllerUpdate(Core::HID::ControllerTriggerType type); |
||||
|
|
||||
|
ImageTransferProcessorExConfig current_config{}; |
||||
|
Core::IrSensor::ImageTransferProcessorState processor_state{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
Core::HID::EmulatedController* npad_device; |
||||
|
int callback_key{}; |
||||
|
|
||||
|
u8* transfer_memory = nullptr; |
||||
|
bool is_transfer_memory_set = false; |
||||
|
}; |
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,27 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/ir_led_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
IrLedProcessor::IrLedProcessor(Core::IrSensor::DeviceFormat& device_format) |
||||
|
: device(device_format) { |
||||
|
device.mode = Core::IrSensor::IrSensorMode::IrLedProcessor; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
IrLedProcessor::~IrLedProcessor() = default; |
||||
|
|
||||
|
void IrLedProcessor::StartProcessor() {} |
||||
|
|
||||
|
void IrLedProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void IrLedProcessor::StopProcessor() {} |
||||
|
|
||||
|
void IrLedProcessor::SetConfig(Core::IrSensor::PackedIrLedProcessorConfig config) { |
||||
|
current_config.light_target = |
||||
|
static_cast<Core::IrSensor::CameraLightTarget>(config.light_target); |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,47 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/bit_field.h" |
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class IrLedProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit IrLedProcessor(Core::IrSensor::DeviceFormat& device_format); |
||||
|
~IrLedProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedIrLedProcessorConfig config); |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::IrLedProcessorConfig |
||||
|
struct IrLedProcessorConfig { |
||||
|
Core::IrSensor::CameraLightTarget light_target; |
||||
|
}; |
||||
|
static_assert(sizeof(IrLedProcessorConfig) == 0x4, "IrLedProcessorConfig is an invalid size"); |
||||
|
|
||||
|
struct IrLedProcessorState { |
||||
|
s64 sampling_number; |
||||
|
u64 timestamp; |
||||
|
std::array<u8, 0x8> data; |
||||
|
}; |
||||
|
static_assert(sizeof(IrLedProcessorState) == 0x18, "IrLedProcessorState is an invalid size"); |
||||
|
|
||||
|
IrLedProcessorConfig current_config{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
}; |
||||
|
|
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,34 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/moment_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
MomentProcessor::MomentProcessor(Core::IrSensor::DeviceFormat& device_format) |
||||
|
: device(device_format) { |
||||
|
device.mode = Core::IrSensor::IrSensorMode::MomentProcessor; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
MomentProcessor::~MomentProcessor() = default; |
||||
|
|
||||
|
void MomentProcessor::StartProcessor() {} |
||||
|
|
||||
|
void MomentProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void MomentProcessor::StopProcessor() {} |
||||
|
|
||||
|
void MomentProcessor::SetConfig(Core::IrSensor::PackedMomentProcessorConfig config) { |
||||
|
current_config.camera_config.exposure_time = config.camera_config.exposure_time; |
||||
|
current_config.camera_config.gain = config.camera_config.gain; |
||||
|
current_config.camera_config.is_negative_used = config.camera_config.is_negative_used; |
||||
|
current_config.camera_config.light_target = |
||||
|
static_cast<Core::IrSensor::CameraLightTarget>(config.camera_config.light_target); |
||||
|
current_config.window_of_interest = config.window_of_interest; |
||||
|
current_config.preprocess = |
||||
|
static_cast<Core::IrSensor::MomentProcessorPreprocess>(config.preprocess); |
||||
|
current_config.preprocess_intensity_threshold = config.preprocess_intensity_threshold; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,61 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/bit_field.h" |
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class MomentProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit MomentProcessor(Core::IrSensor::DeviceFormat& device_format); |
||||
|
~MomentProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedMomentProcessorConfig config); |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::MomentProcessorConfig |
||||
|
struct MomentProcessorConfig { |
||||
|
Core::IrSensor::CameraConfig camera_config; |
||||
|
Core::IrSensor::IrsRect window_of_interest; |
||||
|
Core::IrSensor::MomentProcessorPreprocess preprocess; |
||||
|
u32 preprocess_intensity_threshold; |
||||
|
}; |
||||
|
static_assert(sizeof(MomentProcessorConfig) == 0x28, |
||||
|
"MomentProcessorConfig is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::MomentStatistic |
||||
|
struct MomentStatistic { |
||||
|
f32 average_intensity; |
||||
|
Core::IrSensor::IrsCentroid centroid; |
||||
|
}; |
||||
|
static_assert(sizeof(MomentStatistic) == 0xC, "MomentStatistic is an invalid size"); |
||||
|
|
||||
|
// This is nn::irsensor::MomentProcessorState |
||||
|
struct MomentProcessorState { |
||||
|
s64 sampling_number; |
||||
|
u64 timestamp; |
||||
|
Core::IrSensor::CameraAmbientNoiseLevel ambient_noise_level; |
||||
|
INSERT_PADDING_BYTES(4); |
||||
|
std::array<MomentStatistic, 0x30> stadistic; |
||||
|
}; |
||||
|
static_assert(sizeof(MomentProcessorState) == 0x258, "MomentProcessorState is an invalid size"); |
||||
|
|
||||
|
MomentProcessorConfig current_config{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
}; |
||||
|
|
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,26 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/pointing_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
PointingProcessor::PointingProcessor(Core::IrSensor::DeviceFormat& device_format) |
||||
|
: device(device_format) { |
||||
|
device.mode = Core::IrSensor::IrSensorMode::PointingProcessorMarker; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
PointingProcessor::~PointingProcessor() = default; |
||||
|
|
||||
|
void PointingProcessor::StartProcessor() {} |
||||
|
|
||||
|
void PointingProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void PointingProcessor::StopProcessor() {} |
||||
|
|
||||
|
void PointingProcessor::SetConfig(Core::IrSensor::PackedPointingProcessorConfig config) { |
||||
|
current_config.window_of_interest = config.window_of_interest; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,61 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class PointingProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit PointingProcessor(Core::IrSensor::DeviceFormat& device_format); |
||||
|
~PointingProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedPointingProcessorConfig config); |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::PointingProcessorConfig |
||||
|
struct PointingProcessorConfig { |
||||
|
Core::IrSensor::IrsRect window_of_interest; |
||||
|
}; |
||||
|
static_assert(sizeof(PointingProcessorConfig) == 0x8, |
||||
|
"PointingProcessorConfig is an invalid size"); |
||||
|
|
||||
|
struct PointingProcessorMarkerData { |
||||
|
u8 pointing_status; |
||||
|
INSERT_PADDING_BYTES(3); |
||||
|
u32 unknown; |
||||
|
float unkown_float1; |
||||
|
float position_x; |
||||
|
float position_y; |
||||
|
float unkown_float2; |
||||
|
Core::IrSensor::IrsRect window_of_interest; |
||||
|
}; |
||||
|
static_assert(sizeof(PointingProcessorMarkerData) == 0x20, |
||||
|
"PointingProcessorMarkerData is an invalid size"); |
||||
|
|
||||
|
struct PointingProcessorMarkerState { |
||||
|
s64 sampling_number; |
||||
|
u64 timestamp; |
||||
|
std::array<PointingProcessorMarkerData, 0x3> data; |
||||
|
}; |
||||
|
static_assert(sizeof(PointingProcessorMarkerState) == 0x70, |
||||
|
"PointingProcessorMarkerState is an invalid size"); |
||||
|
|
||||
|
PointingProcessorConfig current_config{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
}; |
||||
|
|
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,67 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
|
||||
|
ProcessorBase::ProcessorBase() {} |
||||
|
ProcessorBase::~ProcessorBase() = default; |
||||
|
|
||||
|
bool ProcessorBase::IsProcessorActive() const { |
||||
|
return is_active; |
||||
|
} |
||||
|
|
||||
|
std::size_t ProcessorBase::GetDataSize(Core::IrSensor::ImageTransferProcessorFormat format) const { |
||||
|
switch (format) { |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size320x240: |
||||
|
return 320 * 240; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size160x120: |
||||
|
return 160 * 120; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size80x60: |
||||
|
return 80 * 60; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size40x30: |
||||
|
return 40 * 30; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size20x15: |
||||
|
return 20 * 15; |
||||
|
default: |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::size_t ProcessorBase::GetDataWidth(Core::IrSensor::ImageTransferProcessorFormat format) const { |
||||
|
switch (format) { |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size320x240: |
||||
|
return 320; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size160x120: |
||||
|
return 160; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size80x60: |
||||
|
return 80; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size40x30: |
||||
|
return 40; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size20x15: |
||||
|
return 20; |
||||
|
default: |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::size_t ProcessorBase::GetDataHeight( |
||||
|
Core::IrSensor::ImageTransferProcessorFormat format) const { |
||||
|
switch (format) { |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size320x240: |
||||
|
return 240; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size160x120: |
||||
|
return 120; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size80x60: |
||||
|
return 60; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size40x30: |
||||
|
return 30; |
||||
|
case Core::IrSensor::ImageTransferProcessorFormat::Size20x15: |
||||
|
return 15; |
||||
|
default: |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,33 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class ProcessorBase { |
||||
|
public: |
||||
|
explicit ProcessorBase(); |
||||
|
virtual ~ProcessorBase(); |
||||
|
|
||||
|
virtual void StartProcessor() = 0; |
||||
|
virtual void SuspendProcessor() = 0; |
||||
|
virtual void StopProcessor() = 0; |
||||
|
|
||||
|
bool IsProcessorActive() const; |
||||
|
|
||||
|
protected: |
||||
|
/// Returns the number of bytes the image uses |
||||
|
std::size_t GetDataSize(Core::IrSensor::ImageTransferProcessorFormat format) const; |
||||
|
|
||||
|
/// Returns the width of the image |
||||
|
std::size_t GetDataWidth(Core::IrSensor::ImageTransferProcessorFormat format) const; |
||||
|
|
||||
|
/// Returns the height of the image |
||||
|
std::size_t GetDataHeight(Core::IrSensor::ImageTransferProcessorFormat format) const; |
||||
|
|
||||
|
bool is_active{false}; |
||||
|
}; |
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,29 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/hid/irsensor/tera_plugin_processor.h"
|
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
TeraPluginProcessor::TeraPluginProcessor(Core::IrSensor::DeviceFormat& device_format) |
||||
|
: device(device_format) { |
||||
|
device.mode = Core::IrSensor::IrSensorMode::TeraPluginProcessor; |
||||
|
device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected; |
||||
|
device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped; |
||||
|
} |
||||
|
|
||||
|
TeraPluginProcessor::~TeraPluginProcessor() = default; |
||||
|
|
||||
|
void TeraPluginProcessor::StartProcessor() {} |
||||
|
|
||||
|
void TeraPluginProcessor::SuspendProcessor() {} |
||||
|
|
||||
|
void TeraPluginProcessor::StopProcessor() {} |
||||
|
|
||||
|
void TeraPluginProcessor::SetConfig(Core::IrSensor::PackedTeraPluginProcessorConfig config) { |
||||
|
current_config.mode = config.mode; |
||||
|
current_config.unknown_1 = config.unknown_1; |
||||
|
current_config.unknown_2 = config.unknown_2; |
||||
|
current_config.unknown_3 = config.unknown_3; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::IRS
|
||||
@ -0,0 +1,53 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "common/bit_field.h" |
||||
|
#include "common/common_types.h" |
||||
|
#include "core/hid/irs_types.h" |
||||
|
#include "core/hle/service/hid/irsensor/processor_base.h" |
||||
|
|
||||
|
namespace Service::IRS { |
||||
|
class TeraPluginProcessor final : public ProcessorBase { |
||||
|
public: |
||||
|
explicit TeraPluginProcessor(Core::IrSensor::DeviceFormat& device_format); |
||||
|
~TeraPluginProcessor() override; |
||||
|
|
||||
|
// Called when the processor is initialized |
||||
|
void StartProcessor() override; |
||||
|
|
||||
|
// Called when the processor is suspended |
||||
|
void SuspendProcessor() override; |
||||
|
|
||||
|
// Called when the processor is stopped |
||||
|
void StopProcessor() override; |
||||
|
|
||||
|
// Sets config parameters of the camera |
||||
|
void SetConfig(Core::IrSensor::PackedTeraPluginProcessorConfig config); |
||||
|
|
||||
|
private: |
||||
|
// This is nn::irsensor::TeraPluginProcessorConfig |
||||
|
struct TeraPluginProcessorConfig { |
||||
|
u8 mode; |
||||
|
u8 unknown_1; |
||||
|
u8 unknown_2; |
||||
|
u8 unknown_3; |
||||
|
}; |
||||
|
static_assert(sizeof(TeraPluginProcessorConfig) == 0x4, |
||||
|
"TeraPluginProcessorConfig is an invalid size"); |
||||
|
|
||||
|
struct TeraPluginProcessorState { |
||||
|
s64 sampling_number; |
||||
|
u64 timestamp; |
||||
|
Core::IrSensor::CameraAmbientNoiseLevel ambient_noise_level; |
||||
|
std::array<u8, 0x12c> data; |
||||
|
}; |
||||
|
static_assert(sizeof(TeraPluginProcessorState) == 0x140, |
||||
|
"TeraPluginProcessorState is an invalid size"); |
||||
|
|
||||
|
TeraPluginProcessorConfig current_config{}; |
||||
|
Core::IrSensor::DeviceFormat& device; |
||||
|
}; |
||||
|
|
||||
|
} // namespace Service::IRS |
||||
@ -0,0 +1,82 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include <fmt/format.h>
|
||||
|
|
||||
|
#include "common/param_package.h"
|
||||
|
#include "input_common/drivers/camera.h"
|
||||
|
|
||||
|
namespace InputCommon { |
||||
|
constexpr PadIdentifier identifier = { |
||||
|
.guid = Common::UUID{}, |
||||
|
.port = 0, |
||||
|
.pad = 0, |
||||
|
}; |
||||
|
|
||||
|
Camera::Camera(std::string input_engine_) : InputEngine(std::move(input_engine_)) { |
||||
|
PreSetController(identifier); |
||||
|
} |
||||
|
|
||||
|
void Camera::SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data) { |
||||
|
const std::size_t desired_width = getImageWidth(); |
||||
|
const std::size_t desired_height = getImageHeight(); |
||||
|
status.data.resize(desired_width * desired_height); |
||||
|
|
||||
|
// Resize image to desired format
|
||||
|
for (std::size_t y = 0; y < desired_height; y++) { |
||||
|
for (std::size_t x = 0; x < desired_width; x++) { |
||||
|
const std::size_t pixel_index = y * desired_width + x; |
||||
|
const std::size_t old_x = width * x / desired_width; |
||||
|
const std::size_t old_y = height * y / desired_height; |
||||
|
const std::size_t data_pixel_index = old_y * width + old_x; |
||||
|
status.data[pixel_index] = static_cast<u8>(data[data_pixel_index] & 0xFF); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
SetCamera(identifier, status); |
||||
|
} |
||||
|
|
||||
|
std::size_t Camera::getImageWidth() const { |
||||
|
switch (status.format) { |
||||
|
case Common::Input::CameraFormat::Size320x240: |
||||
|
return 320; |
||||
|
case Common::Input::CameraFormat::Size160x120: |
||||
|
return 160; |
||||
|
case Common::Input::CameraFormat::Size80x60: |
||||
|
return 80; |
||||
|
case Common::Input::CameraFormat::Size40x30: |
||||
|
return 40; |
||||
|
case Common::Input::CameraFormat::Size20x15: |
||||
|
return 20; |
||||
|
case Common::Input::CameraFormat::None: |
||||
|
default: |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::size_t Camera::getImageHeight() const { |
||||
|
switch (status.format) { |
||||
|
case Common::Input::CameraFormat::Size320x240: |
||||
|
return 240; |
||||
|
case Common::Input::CameraFormat::Size160x120: |
||||
|
return 120; |
||||
|
case Common::Input::CameraFormat::Size80x60: |
||||
|
return 60; |
||||
|
case Common::Input::CameraFormat::Size40x30: |
||||
|
return 30; |
||||
|
case Common::Input::CameraFormat::Size20x15: |
||||
|
return 15; |
||||
|
case Common::Input::CameraFormat::None: |
||||
|
default: |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Common::Input::CameraError Camera::SetCameraFormat( |
||||
|
[[maybe_unused]] const PadIdentifier& identifier_, |
||||
|
const Common::Input::CameraFormat camera_format) { |
||||
|
status.format = camera_format; |
||||
|
return Common::Input::CameraError::None; |
||||
|
} |
||||
|
|
||||
|
} // namespace InputCommon
|
||||
@ -0,0 +1,29 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "input_common/input_engine.h" |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
/** |
||||
|
* A button device factory representing a keyboard. It receives keyboard events and forward them |
||||
|
* to all button devices it created. |
||||
|
*/ |
||||
|
class Camera final : public InputEngine { |
||||
|
public: |
||||
|
explicit Camera(std::string input_engine_); |
||||
|
|
||||
|
void SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data); |
||||
|
|
||||
|
std::size_t getImageWidth() const; |
||||
|
std::size_t getImageHeight() const; |
||||
|
|
||||
|
Common::Input::CameraError SetCameraFormat(const PadIdentifier& identifier_, |
||||
|
Common::Input::CameraFormat camera_format) override; |
||||
|
|
||||
|
Common::Input::CameraStatus status{}; |
||||
|
}; |
||||
|
|
||||
|
} // namespace InputCommon |
||||
@ -0,0 +1,138 @@ |
|||||
|
// Text : Copyright 2022 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
|
||||
|
#include <memory>
|
||||
|
#include <QCameraImageCapture>
|
||||
|
#include <QCameraInfo>
|
||||
|
#include <QStandardItemModel>
|
||||
|
#include <QTimer>
|
||||
|
|
||||
|
#include "input_common/drivers/camera.h"
|
||||
|
#include "input_common/main.h"
|
||||
|
#include "ui_configure_camera.h"
|
||||
|
#include "yuzu/configuration/config.h"
|
||||
|
#include "yuzu/configuration/configure_camera.h"
|
||||
|
|
||||
|
ConfigureCamera::ConfigureCamera(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_) |
||||
|
: QDialog(parent), input_subsystem{input_subsystem_}, |
||||
|
ui(std::make_unique<Ui::ConfigureCamera>()) { |
||||
|
ui->setupUi(this); |
||||
|
|
||||
|
connect(ui->restore_defaults_button, &QPushButton::clicked, this, |
||||
|
&ConfigureCamera::RestoreDefaults); |
||||
|
connect(ui->preview_button, &QPushButton::clicked, this, &ConfigureCamera::PreviewCamera); |
||||
|
|
||||
|
auto blank_image = QImage(320, 240, QImage::Format::Format_RGB32); |
||||
|
blank_image.fill(Qt::black); |
||||
|
DisplayCapturedFrame(0, blank_image); |
||||
|
|
||||
|
LoadConfiguration(); |
||||
|
resize(0, 0); |
||||
|
} |
||||
|
|
||||
|
ConfigureCamera::~ConfigureCamera() = default; |
||||
|
|
||||
|
void ConfigureCamera::PreviewCamera() { |
||||
|
const auto index = ui->ir_sensor_combo_box->currentIndex(); |
||||
|
bool camera_found = false; |
||||
|
const QList<QCameraInfo> cameras = QCameraInfo::availableCameras(); |
||||
|
for (const QCameraInfo& cameraInfo : cameras) { |
||||
|
if (input_devices[index] == cameraInfo.deviceName().toStdString() || |
||||
|
input_devices[index] == "Auto") { |
||||
|
LOG_INFO(Frontend, "Selected Camera {} {}", cameraInfo.description().toStdString(), |
||||
|
cameraInfo.deviceName().toStdString()); |
||||
|
camera = std::make_unique<QCamera>(cameraInfo); |
||||
|
camera_found = true; |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Clear previous frame
|
||||
|
auto blank_image = QImage(320, 240, QImage::Format::Format_RGB32); |
||||
|
blank_image.fill(Qt::black); |
||||
|
DisplayCapturedFrame(0, blank_image); |
||||
|
|
||||
|
if (!camera_found) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
camera_capture = std::make_unique<QCameraImageCapture>(camera.get()); |
||||
|
connect(camera_capture.get(), &QCameraImageCapture::imageCaptured, this, |
||||
|
&ConfigureCamera::DisplayCapturedFrame); |
||||
|
camera->unload(); |
||||
|
camera->setCaptureMode(QCamera::CaptureViewfinder); |
||||
|
camera->load(); |
||||
|
camera->start(); |
||||
|
|
||||
|
pending_snapshots = 0; |
||||
|
is_virtual_camera = false; |
||||
|
|
||||
|
camera_timer = std::make_unique<QTimer>(); |
||||
|
connect(camera_timer.get(), &QTimer::timeout, [this] { |
||||
|
// If the camera doesn't capture, test for virtual cameras
|
||||
|
if (pending_snapshots > 5) { |
||||
|
is_virtual_camera = true; |
||||
|
} |
||||
|
// Virtual cameras like obs need to reset the camera every capture
|
||||
|
if (is_virtual_camera) { |
||||
|
camera->stop(); |
||||
|
camera->start(); |
||||
|
} |
||||
|
pending_snapshots++; |
||||
|
camera_capture->capture(); |
||||
|
}); |
||||
|
|
||||
|
camera_timer->start(250); |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::DisplayCapturedFrame(int requestId, const QImage& img) { |
||||
|
LOG_INFO(Frontend, "ImageCaptured {} {}", img.width(), img.height()); |
||||
|
const auto converted = img.scaled(320, 240, Qt::AspectRatioMode::IgnoreAspectRatio, |
||||
|
Qt::TransformationMode::SmoothTransformation); |
||||
|
ui->preview_box->setPixmap(QPixmap::fromImage(converted)); |
||||
|
pending_snapshots = 0; |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::changeEvent(QEvent* event) { |
||||
|
if (event->type() == QEvent::LanguageChange) { |
||||
|
RetranslateUI(); |
||||
|
} |
||||
|
|
||||
|
QDialog::changeEvent(event); |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::RetranslateUI() { |
||||
|
ui->retranslateUi(this); |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::ApplyConfiguration() { |
||||
|
const auto index = ui->ir_sensor_combo_box->currentIndex(); |
||||
|
Settings::values.ir_sensor_device.SetValue(input_devices[index]); |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::LoadConfiguration() { |
||||
|
input_devices.clear(); |
||||
|
ui->ir_sensor_combo_box->clear(); |
||||
|
input_devices.push_back("Auto"); |
||||
|
ui->ir_sensor_combo_box->addItem(tr("Auto")); |
||||
|
const auto cameras = QCameraInfo::availableCameras(); |
||||
|
for (const QCameraInfo& cameraInfo : cameras) { |
||||
|
input_devices.push_back(cameraInfo.deviceName().toStdString()); |
||||
|
ui->ir_sensor_combo_box->addItem(cameraInfo.description()); |
||||
|
} |
||||
|
|
||||
|
const auto current_device = Settings::values.ir_sensor_device.GetValue(); |
||||
|
|
||||
|
const auto devices_it = std::find_if( |
||||
|
input_devices.begin(), input_devices.end(), |
||||
|
[current_device](const std::string& device) { return device == current_device; }); |
||||
|
const int device_index = |
||||
|
devices_it != input_devices.end() |
||||
|
? static_cast<int>(std::distance(input_devices.begin(), devices_it)) |
||||
|
: 0; |
||||
|
ui->ir_sensor_combo_box->setCurrentIndex(device_index); |
||||
|
} |
||||
|
|
||||
|
void ConfigureCamera::RestoreDefaults() { |
||||
|
ui->ir_sensor_combo_box->setCurrentIndex(0); |
||||
|
} |
||||
@ -0,0 +1,54 @@ |
|||||
|
// Text : Copyright 2022 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-3.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <memory> |
||||
|
#include <QDialog> |
||||
|
|
||||
|
class QTimer; |
||||
|
class QCamera; |
||||
|
class QCameraImageCapture; |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
class InputSubsystem; |
||||
|
} // namespace InputCommon |
||||
|
|
||||
|
namespace Ui { |
||||
|
class ConfigureCamera; |
||||
|
} |
||||
|
|
||||
|
class ConfigureCamera : public QDialog { |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
explicit ConfigureCamera(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_); |
||||
|
~ConfigureCamera() override; |
||||
|
|
||||
|
void ApplyConfiguration(); |
||||
|
|
||||
|
private: |
||||
|
void changeEvent(QEvent* event) override; |
||||
|
void RetranslateUI(); |
||||
|
|
||||
|
/// Load configuration settings. |
||||
|
void LoadConfiguration(); |
||||
|
|
||||
|
/// Restore all buttons to their default values. |
||||
|
void RestoreDefaults(); |
||||
|
|
||||
|
void DisplayCapturedFrame(int requestId, const QImage& img); |
||||
|
|
||||
|
/// Loads and signals the current selected camera to display a frame |
||||
|
void PreviewCamera(); |
||||
|
|
||||
|
InputCommon::InputSubsystem* input_subsystem; |
||||
|
|
||||
|
bool is_virtual_camera; |
||||
|
int pending_snapshots; |
||||
|
std::unique_ptr<QCamera> camera; |
||||
|
std::unique_ptr<QCameraImageCapture> camera_capture; |
||||
|
std::unique_ptr<QTimer> camera_timer; |
||||
|
std::vector<std::string> input_devices; |
||||
|
std::unique_ptr<Ui::ConfigureCamera> ui; |
||||
|
}; |
||||
@ -0,0 +1,170 @@ |
|||||
|
<?xml version="1.0" encoding="UTF-8"?> |
||||
|
<ui version="4.0"> |
||||
|
<class>ConfigureCamera</class> |
||||
|
<widget class="QDialog" name="ConfigureCamera"> |
||||
|
<property name="geometry"> |
||||
|
<rect> |
||||
|
<x>0</x> |
||||
|
<y>0</y> |
||||
|
<width>298</width> |
||||
|
<height>339</height> |
||||
|
</rect> |
||||
|
</property> |
||||
|
<property name="windowTitle"> |
||||
|
<string>Configure Infrared Camera</string> |
||||
|
</property> |
||||
|
<layout class="QVBoxLayout" name="verticalLayout"> |
||||
|
<item> |
||||
|
<widget class="QLabel" name="label_2"> |
||||
|
<property name="minimumSize"> |
||||
|
<size> |
||||
|
<width>280</width> |
||||
|
<height>0</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
<property name="text"> |
||||
|
<string>Select where the image of the emulated camera comes from. It may be a virtual camera or a real camera.</string> |
||||
|
</property> |
||||
|
<property name="wordWrap"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<spacer name="verticalSpacer_2"> |
||||
|
<property name="orientation"> |
||||
|
<enum>Qt::Vertical</enum> |
||||
|
</property> |
||||
|
<property name="sizeType"> |
||||
|
<enum>QSizePolicy::Fixed</enum> |
||||
|
</property> |
||||
|
<property name="sizeHint" stdset="0"> |
||||
|
<size> |
||||
|
<width>20</width> |
||||
|
<height>20</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
</spacer> |
||||
|
</item> |
||||
|
<item> |
||||
|
<widget class="QGroupBox" name="gridGroupBox"> |
||||
|
<property name="title"> |
||||
|
<string>Camera Image Source:</string> |
||||
|
</property> |
||||
|
<layout class="QGridLayout" name="gridLayout"> |
||||
|
<item row="0" column="0"> |
||||
|
<spacer name="horizontalSpacer"> |
||||
|
<property name="orientation"> |
||||
|
<enum>Qt::Horizontal</enum> |
||||
|
</property> |
||||
|
<property name="sizeHint" stdset="0"> |
||||
|
<size> |
||||
|
<width>40</width> |
||||
|
<height>20</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
</spacer> |
||||
|
</item> |
||||
|
<item row="0" column="1"> |
||||
|
<widget class="QLabel" name="label_3"> |
||||
|
<property name="text"> |
||||
|
<string>Input device:</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item row="0" column="2"> |
||||
|
<widget class="QComboBox" name="ir_sensor_combo_box"/> |
||||
|
</item> |
||||
|
<item row="0" column="3"> |
||||
|
<spacer name="horizontalSpacer_2"> |
||||
|
<property name="orientation"> |
||||
|
<enum>Qt::Horizontal</enum> |
||||
|
</property> |
||||
|
<property name="sizeHint" stdset="0"> |
||||
|
<size> |
||||
|
<width>40</width> |
||||
|
<height>20</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
</spacer> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</widget> |
||||
|
</item><item> |
||||
|
<widget class="QGroupBox" name="previewBox"> |
||||
|
<property name="title"> |
||||
|
<string>Preview</string> |
||||
|
</property> |
||||
|
<layout class="QVBoxLayout" name="verticalLayout_3"> |
||||
|
<item> |
||||
|
<widget class="QLabel" name="preview_box"> |
||||
|
<property name="minimumSize"> |
||||
|
<size> |
||||
|
<width>320</width> |
||||
|
<height>240</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
<property name="toolTip"> |
||||
|
<string>Resolution: 320*240</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<widget class="QPushButton" name="preview_button"> |
||||
|
<property name="text"> |
||||
|
<string>Click to preview</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<spacer name="verticalSpacer"> |
||||
|
<property name="orientation"> |
||||
|
<enum>Qt::Vertical</enum> |
||||
|
</property> |
||||
|
<property name="sizeHint" stdset="0"> |
||||
|
<size> |
||||
|
<width>20</width> |
||||
|
<height>40</height> |
||||
|
</size> |
||||
|
</property> |
||||
|
</spacer> |
||||
|
</item> |
||||
|
<item> |
||||
|
<layout class="QHBoxLayout" name="horizontalLayout"> |
||||
|
<item> |
||||
|
<widget class="QPushButton" name="restore_defaults_button"> |
||||
|
<property name="text"> |
||||
|
<string>Restore Defaults</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<widget class="QDialogButtonBox" name="buttonBox"> |
||||
|
<property name="standardButtons"> |
||||
|
<set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</widget> |
||||
|
<resources/> |
||||
|
<connections> |
||||
|
<connection> |
||||
|
<sender>buttonBox</sender> |
||||
|
<signal>accepted()</signal> |
||||
|
<receiver>ConfigureCamera</receiver> |
||||
|
<slot>accept()</slot> |
||||
|
</connection> |
||||
|
<connection> |
||||
|
<sender>buttonBox</sender> |
||||
|
<signal>rejected()</signal> |
||||
|
<receiver>ConfigureCamera</receiver> |
||||
|
<slot>reject()</slot> |
||||
|
</connection> |
||||
|
</connections> |
||||
|
</ui> |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue