diff --git a/BUILDING.md b/BUILDING.md index b2ad0d5a5..205e5339c 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -14,7 +14,7 @@ ```console sudo apt-get update -sudo apt-get install build-essential cmake flatbuffers-compiler git libasound2-dev libayatana-appindicator3-dev libegl-dev libflatbuffers-dev libftdi1-dev libgl-dev libglvnd-dev libgtk-3-dev liblzma-dev libpipewire-0.3-dev libssl-dev libsystemd-dev libturbojpeg0-dev libusb-1.0-0-dev libx11-dev libzstd-dev ninja-build patchelf pkg-config python3 qt6-serialport-dev qt6-base-dev unzip wget +sudo apt-get install build-essential cmake flatbuffers-compiler git libasound2-dev libayatana-appindicator3-dev libegl-dev libflatbuffers-dev libftdi1-dev libgl-dev libglvnd-dev libgtk-3-dev liblzma-dev libpipewire-0.3-dev libssl-dev libsystemd-dev libturbojpeg0-dev libusb-1.0-0-dev libx11-dev libzstd-dev ninja-build patchelf pkg-config python3 qt6-serialport-dev qt6-base-dev unzip wget chrpath ``` For Raspberry Pi CEC support (optional) @@ -25,7 +25,7 @@ sudo apt-get install libcec-dev libp8-platform-dev libudev-dev ### Fedora ```console -sudo dnf -y install alsa-lib-devel chrpath cmake fedora-packager flatbuffers-compiler flatbuffers-devel gcc gcc-c++ git gtk3-devel libX11-devel libayatana-appindicator-gtk3-devel libftdi-c++-devel libglvnd-devel libusb1-devel libzstd-devel mesa-libEGL-devel mesa-libGL-devel ninja-build openssl-devel pipewire-devel pkg-config qt6-qtbase-devel qt6-qtserialport-devel systemd-devel turbojpeg-devel unzip wget xz-devel +sudo dnf -y install alsa-lib-devel chrpath cmake fedora-packager flatbuffers-compiler flatbuffers-devel gcc gcc-c++ git gtk3-devel libX11-devel libayatana-appindicator-gtk3-devel libftdi-c++-devel libglvnd-devel libusb1-devel libzstd-devel mesa-libEGL-devel mesa-libGL-devel ninja-build openssl-devel pipewire-devel pkg-config qt6-qtbase-devel qt6-qtserialport-devel systemd-devel turbojpeg-devel unzip wget xz-devel chrpath ``` @@ -34,7 +34,7 @@ sudo dnf -y install alsa-lib-devel chrpath cmake fedora-packager flatbuffers-com ```console sudo pacman -Syy -sudo pacman -S alsa-lib base-devel bash binutils chrpath cmake dpkg fakeroot flatbuffers freetds git gtk3 libayatana-appindicator libfbclient libftdi libglvnd libjpeg-turbo libx11 mariadb-libs mesa ninja openssl pipewire pkgfile postgresql-libs python qt6-base qt6-serialport sdbus-cpp systemd-libs unzip wayland wget xz +sudo pacman -S alsa-lib base-devel bash binutils chrpath cmake dpkg fakeroot flatbuffers freetds git gtk3 libayatana-appindicator libfbclient libftdi libglvnd libjpeg-turbo libx11 mariadb-libs mesa ninja openssl pipewire pkgfile postgresql-libs python qt6-base qt6-serialport sdbus-cpp systemd-libs unzip wayland wget xz chrpath ``` ### Windows @@ -223,4 +223,4 @@ Use -D prefix when configuring the build. * USE_SYSTEM_NANOPB_LIBS = ON | OFF, prefer system nanopb libs * USE_SYSTEM_STB_LIBS = ON | OFF, prefer system stb libs * USE_STATIC_QT_PLUGINS = ON | OFF, embed static QT-plugins into the app - * USE_STANDARD_INSTALLER_NAME = ON | OFF, use standard Linux package naming \ No newline at end of file + * USE_STANDARD_INSTALLER_NAME = ON | OFF, use standard Linux package naming diff --git a/CHANGELOG.md b/CHANGELOG.md index 17c029aad..5e176db8f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,15 @@ +- Fix: Initial smoothing surge after period of static video input (#1410) - fix for v22beta1 🆕 +- Fix: Minimum brightness preservation in YUV and Hybrid-Inertia smoothing modes (#1410) - fix for v22beta1 🆕 +- upgrades old style format logging (with %) to c++20 format in some places (#1410) - fix for v22beta1 🆕 +- restores custom user RGB order at the start (#1410) - fix for v22beta1 🆕 +- restores compatibility with Qt5.15 (#1410) - fix for v22beta1 🆕 +- Improved state management of the software grabber during sleep and monitor‑suspend events (#1410) - fix for v22beta1 🆕 + - PipeWire is particularly sensitive to sessions resuming too early after such events and, despite having provided a saved session token, would display a new source select dialog after resume when screen‑lock‑after‑suspend was enabled +- Set disableOnLocked option enabled by default, because software grabbers for ex. Pipewire wont function properly without it (#1410) - fix for v22beta1 🆕 +- Fix translation resources +- Infinite Color Engine: new anti-flickering filter in the smoothing configuration (#1410) - fix for v22beta1 🆕 + - Implements an anti-flickering filter that minimizes quantization jitter on 8-bit-per-channel drivers (24-bit RGB). Deep color capable drivers (like Philips Hue using entertainment mode) are bypassed as they don't suffer from LSB oscillation. +- Improved handshake stability connecting to Philips Hue bridge using OpenSSL 3.2+ (#1410) - fix for v22beta1 🆕 - Infinite Color Engine - Breaking 24-bit Limits (#1261) - v22beta1 🆕 - Floating-Point Precision: All color computations use high-precision floating-point arithmetic, eliminating cumulative rounding errors for more accurate results - Linear sRGB Accuracy: Core color transformations are processed in linear sRGB space, ensuring physically correct and consistent light reproduction diff --git a/cmake/installers.cmake b/cmake/installers.cmake index 7c1a750c1..efa8ba41e 100644 --- a/cmake/installers.cmake +++ b/cmake/installers.cmake @@ -318,6 +318,7 @@ macro(DeployUnix TARGET) install(CODE "set(TARGET_FILE \"${TARGET_FILE}\")" COMPONENT "HyperHDR") install(CODE "set(PREREQUISITE_LIBS \"${PREREQUISITE_LIBS}\")" COMPONENT "HyperHDR") install(CODE "set(QT_PLUGINS_DIR \"${QT_PLUGINS_DIR}\")" COMPONENT "HyperHDR") + install(CODE "set(TEMP_RPATH_DIR \"${CMAKE_CURRENT_BINARY_DIR}/temp_rpath_fix\")" COMPONENT "HyperHDR") install(CODE [[ @@ -370,8 +371,6 @@ macro(DeployUnix TARGET) "ld-" "libasound" "libblkid" - "libbrotlicommon" - "libbrotlidec" "libffi" "libgio-2" "libgmodule-2" @@ -461,8 +460,7 @@ macro(DeployUnix TARGET) endif() endforeach() - # Copy dependencies to 'share/hyperhdr/lib/external' - set(TEMP_RPATH_DIR "${CMAKE_CURRENT_BINARY_DIR}/temp_rpath_fix") + # Copy dependencies to 'share/hyperhdr/lib/external' file(MAKE_DIRECTORY ${TEMP_RPATH_DIR}) foreach(PREREQUISITE_LIB ${PREREQUISITE_LIBS}) set(FILE_TO_INSTALL ${PREREQUISITE_LIB}) diff --git a/include/base/HyperHdrInstance.h b/include/base/HyperHdrInstance.h index d8fc571df..b42224aae 100644 --- a/include/base/HyperHdrInstance.h +++ b/include/base/HyperHdrInstance.h @@ -117,7 +117,7 @@ public slots: void SignalAdjustmentUpdated(QJsonArray newConfig); void SignalFinalOutputColorsReady(SharedOutputColors nonlinearRgbColors); void SignalSmoothingClockTick(); - void SignalSmoothingRestarted(int suggestedInterval); + void SignalSmoothingRestarted(int suggestedInterval, bool antiflickeringfilter); void SignalRawColorsChanged(QVector ledValues); void SignalInstanceJustStarted(); void SignalColorIsSet(ColorRgb color, int duration); diff --git a/include/infinite-color-engine/CoreInfiniteEngine.h b/include/infinite-color-engine/CoreInfiniteEngine.h index 37282093e..cbf69bfe8 100644 --- a/include/infinite-color-engine/CoreInfiniteEngine.h +++ b/include/infinite-color-engine/CoreInfiniteEngine.h @@ -25,10 +25,11 @@ class CoreInfiniteEngine : public QObject Q_OBJECT public: - CoreInfiniteEngine(HyperHdrInstance* hyperhdr); + CoreInfiniteEngine(HyperHdrInstance* hyperhdr, LedString::ColorOrder colorOrder); ~CoreInfiniteEngine() = default; int getSuggestedInterval(); + bool getAntiFlickeringFilterState(); unsigned addCustomSmoothingConfig(unsigned cfgID, int settlingTime_ms, double ledUpdateFrequency_hz, bool pause); void setCurrentSmoothingConfigParams(unsigned cfgID); void incomingColors(std::vector&& _ledBuffer); diff --git a/include/infinite-color-engine/InfiniteExponentialInterpolator.h b/include/infinite-color-engine/InfiniteExponentialInterpolator.h index 29dda862e..e8f0a94d6 100644 --- a/include/infinite-color-engine/InfiniteExponentialInterpolator.h +++ b/include/infinite-color-engine/InfiniteExponentialInterpolator.h @@ -18,7 +18,7 @@ class InfiniteExponentialInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; diff --git a/include/infinite-color-engine/InfiniteHybridInterpolator.h b/include/infinite-color-engine/InfiniteHybridInterpolator.h index e48f2fc4d..973aeed7d 100644 --- a/include/infinite-color-engine/InfiniteHybridInterpolator.h +++ b/include/infinite-color-engine/InfiniteHybridInterpolator.h @@ -17,7 +17,7 @@ class InfiniteHybridInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_to_yuv_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; void setSpringiness(float stiffness, float damping) override; diff --git a/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h b/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h index df00698ea..8265d685e 100644 --- a/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h +++ b/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h @@ -17,7 +17,7 @@ class InfiniteHybridRgbInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; void setSpringiness(float stiffness, float damping) override; diff --git a/include/infinite-color-engine/InfiniteInterpolator.h b/include/infinite-color-engine/InfiniteInterpolator.h index 3ef04a852..913f7f357 100644 --- a/include/infinite-color-engine/InfiniteInterpolator.h +++ b/include/infinite-color-engine/InfiniteInterpolator.h @@ -20,7 +20,7 @@ class InfiniteInterpolator { virtual void setTargetColors(std::vector&& new_rgb_targets, float startTimeMs, bool debug) = 0; virtual void updateCurrentColors(float currentTimeMs) = 0; - virtual SharedOutputColors getCurrentColors() = 0; + virtual SharedOutputColors getCurrentColors(float minBrightness) = 0; virtual void setTransitionDuration(float /*durationMs*/) {}; virtual void setSpringiness(float /*stiffness*/, float /*damping*/) {}; diff --git a/include/infinite-color-engine/InfiniteProcessing.h b/include/infinite-color-engine/InfiniteProcessing.h index 7f831d4db..1866fc945 100644 --- a/include/infinite-color-engine/InfiniteProcessing.h +++ b/include/infinite-color-engine/InfiniteProcessing.h @@ -69,7 +69,7 @@ class InfiniteProcessing : public QObject }; InfiniteProcessing(); - InfiniteProcessing(const QJsonDocument& config, const LoggerName& _log); + InfiniteProcessing(const QJsonDocument& config, LedString::ColorOrder colorOrder, const LoggerName& _log); ~InfiniteProcessing() = default; void setProcessingEnabled(bool enabled); @@ -107,6 +107,7 @@ class InfiniteProcessing : public QObject void setPowerLimit(float powerLimit); void applyPowerLimit(std::vector>& linearRgbColors) const; + std::optional getMinimalBacklight(); void setMinimalBacklight(float minimalLevel, bool coloreBacklight); void applyMinimalBacklight(linalg::vec& color) const; diff --git a/include/infinite-color-engine/InfiniteRgbInterpolator.h b/include/infinite-color-engine/InfiniteRgbInterpolator.h index 74497e072..18137fe6b 100644 --- a/include/infinite-color-engine/InfiniteRgbInterpolator.h +++ b/include/infinite-color-engine/InfiniteRgbInterpolator.h @@ -17,7 +17,7 @@ class InfiniteRgbInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; void setSmoothingFactor(float factor) override; diff --git a/include/infinite-color-engine/InfiniteSmoothing.h b/include/infinite-color-engine/InfiniteSmoothing.h index fe23dd12e..d645ed036 100644 --- a/include/infinite-color-engine/InfiniteSmoothing.h +++ b/include/infinite-color-engine/InfiniteSmoothing.h @@ -35,11 +35,12 @@ class InfiniteSmoothing : public QObject void setEnable(bool enable); bool isEnabled() const; - void incomingColors(std::vector&& nonlinearRgbColors); + void incomingColors(std::vector&& nonlinearRgbColors, std::optional minimalBacklight); unsigned addCustomSmoothingConfig(unsigned cfgID, int settlingTime_ms, double ledUpdateFrequency_hz, bool pause); void setCurrentSmoothingConfigParams(unsigned cfgID); bool selectConfig(unsigned cfgId); int getSuggestedInterval(); + bool getAntiFlickeringFilterState(); static constexpr auto SMOOTHING_EFFECT_CONFIGS_START = 1; @@ -92,4 +93,6 @@ private slots: bool _infoInput; int _coolDown; long long _lastSentFrame; + bool _antiFlickeringFilter; + float _minimalBacklight; }; diff --git a/include/infinite-color-engine/InfiniteStepperInterpolator.h b/include/infinite-color-engine/InfiniteStepperInterpolator.h index 3ac27831a..7b8267d8c 100644 --- a/include/infinite-color-engine/InfiniteStepperInterpolator.h +++ b/include/infinite-color-engine/InfiniteStepperInterpolator.h @@ -18,7 +18,7 @@ class InfiniteStepperInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; diff --git a/include/infinite-color-engine/InfiniteYuvInterpolator.h b/include/infinite-color-engine/InfiniteYuvInterpolator.h index f42e9cf44..acf485700 100644 --- a/include/infinite-color-engine/InfiniteYuvInterpolator.h +++ b/include/infinite-color-engine/InfiniteYuvInterpolator.h @@ -17,7 +17,7 @@ class InfiniteYuvInterpolator : public InfiniteInterpolator void setTargetColors(std::vector&& new_rgb_to_yuv_targets, float startTimeMs, bool debug = false) override; void updateCurrentColors(float currentTimeMs) override; - SharedOutputColors getCurrentColors() override; + SharedOutputColors getCurrentColors(float minBrightness = 0.f) override; void setTransitionDuration(float durationMs) override; void setMaxLuminanceChangePerFrame(float maxChangePerStep) override; diff --git a/include/led-drivers/LedDevice.h b/include/led-drivers/LedDevice.h index e12936a40..5f7ef7af3 100644 --- a/include/led-drivers/LedDevice.h +++ b/include/led-drivers/LedDevice.h @@ -70,7 +70,7 @@ public slots: virtual bool switchOn(); virtual bool switchOff(); void blinking(QJsonObject params); - void smoothingRestarted(int newSmoothingInterval); + void smoothingRestarted(int newSmoothingInterval, bool antiflickeringfilter); int hasLedClock(); void pauseRetryTimer(bool mode); @@ -125,6 +125,7 @@ public slots: bool _isOn; bool _isDeviceInError; + bool _antiFlickeringFilter; int _maxRetry; int _currentRetry; QString _customInfo; @@ -145,6 +146,7 @@ protected slots: std::atomic_bool _isRefreshEnabled; std::atomic_bool _newFrame2Send; SharedOutputColors _lastLedValues; + SharedOutputColors _lastFinityLedValues; struct LedStats { diff --git a/include/led-drivers/LedDeviceWrapper.h b/include/led-drivers/LedDeviceWrapper.h index 62af5d5b7..0055649be 100644 --- a/include/led-drivers/LedDeviceWrapper.h +++ b/include/led-drivers/LedDeviceWrapper.h @@ -22,7 +22,7 @@ class LedDeviceWrapper : public QObject explicit LedDeviceWrapper(HyperHdrInstance* ownerInstance); virtual ~LedDeviceWrapper(); - void createLedDevice(QJsonObject config, int smoothingInterval, bool disableOnStartup); + void createLedDevice(QJsonObject config, int smoothingInterval, bool antiFlickeringFilter, bool disableOnStartup); static QJsonObject getLedDeviceSchemas(); QString getActiveDeviceType() const; bool enabled() const; diff --git a/include/precompiled_hyperhdr_headers/AllHeaders_pch.h b/include/precompiled_hyperhdr_headers/AllHeaders_pch.h index 17f738280..e755ba001 100644 --- a/include/precompiled_hyperhdr_headers/AllHeaders_pch.h +++ b/include/precompiled_hyperhdr_headers/AllHeaders_pch.h @@ -68,6 +68,8 @@ #include #include #include + #include + #include #if __has_include() #include diff --git a/include/utils/Macros.h b/include/utils/Macros.h index e58355e19..ab029c129 100644 --- a/include/utils/Macros.h +++ b/include/utils/Macros.h @@ -1,14 +1,10 @@ #pragma once -#ifndef PCH_ENABLED - #include -#endif - /* Macros.h * * MIT License * -* Copyright (c) 2020-2025 awawa-dev +* Copyright (c) 2020-2026 awawa-dev * * Project homesite: https://github.com/awawa-dev/HyperHDR * @@ -31,11 +27,60 @@ * SOFTWARE. */ -inline void SAFE_CALL_TEST_FUN() {}; +#ifndef PCH_ENABLED + #include + #include + #include + #include +#endif + +#if defined(QT_DEBUG) && QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) + #include + #include + #define QT_METATYPE_CHECK_INTERNAL(ptype, method, n) \ + if (!QMetaType::fromName(#ptype).isValid()) qCritical("HyperHDR Safety Warning: Type '%s' used in method '%s' (arg %d) is NOT registered! Queued calls will fail.", #ptype, #method, n); +#else + #define QT_METATYPE_CHECK_INTERNAL(ptype, method, n) +#endif + +namespace hyperhdr::macros { + inline void SAFE_CALL_TEST_FUN() {}; + + template struct SafeSlotArg; + template + struct SafeSlotArg { + using T = std::remove_cvref_t>>; + }; + template + struct SafeSlotArg { + using T = std::remove_cvref_t>>; + }; + + template struct SafeSlotRet; + template + struct SafeSlotRet { + using Type = std::remove_cvref_t; + }; + template + struct SafeSlotRet { + using Type = std::remove_cvref_t; + }; +} + +#define SCHK_ARG(n, target, method, ptype, pvalue) \ +{ \ + static_assert(std::same_as::method)>::T, ptype>, "Parameter " #n " type mismatch for Qt slot: " #method); \ + static_assert(std::convertible_to, ptype>, "The value passed as parameter " #n " does not match the declared type: " #ptype); \ + QT_METATYPE_CHECK_INTERNAL(ptype, method, n) \ +} + +#define SCHK_RET(target, method, rtype) \ + static_assert(std::same_as::method)>::Type, rtype>, "Return type mismatch for Qt slot: " #method) #define SAFE_CALL_0_RET(target, method, returnType, result, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_RET(target, method, returnType); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_RETURN_ARG(returnType, result)); \ else \ @@ -44,7 +89,9 @@ inline void SAFE_CALL_TEST_FUN() {}; #define SAFE_CALL_1_RET(target, method, returnType, result, p1type, p1value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_RET(target, method, returnType); \ + SCHK_ARG(0, target, method, p1type, p1value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_RETURN_ARG(returnType, result), Q_ARG(p1type, p1value)); \ else \ @@ -53,7 +100,9 @@ inline void SAFE_CALL_TEST_FUN() {}; #define SAFE_CALL_2_RET(target, method, returnType, result, p1type, p1value, p2type, p2value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_RET(target, method, returnType); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_RETURN_ARG(returnType, result), Q_ARG(p1type, p1value), Q_ARG(p2type, p2value)); \ else \ @@ -62,16 +111,20 @@ inline void SAFE_CALL_TEST_FUN() {}; #define SAFE_CALL_3_RET(target, method, returnType, result, p1type, p1value, p2type, p2value, p3type, p3value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_RET(target, method, returnType); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_RETURN_ARG(returnType, result), Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value)); \ else \ result = target->method(p1value, p2value, p3value); \ } -#define SAFE_CALL_4_RET(target, method, returnType, result, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value , ...) \ +#define SAFE_CALL_4_RET(target, method, returnType, result, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_RET(target, method, returnType); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_RETURN_ARG(returnType, result), Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value)); \ else \ @@ -80,7 +133,7 @@ inline void SAFE_CALL_TEST_FUN() {}; #define QUEUE_CALL_0(target, method, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection); \ else \ @@ -89,52 +142,57 @@ inline void SAFE_CALL_TEST_FUN() {}; #define QUEUE_CALL_1(target, method, p1type, p1value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value)); \ else \ - target->method((p1type) p1value); \ + target->method(p1value); \ } #define QUEUE_CALL_2(target, method, p1type, p1value, p2type, p2value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value)); \ else \ - target->method((p1type) p1value, (p2type) p2value); \ + target->method(p1value, p2value); \ } #define QUEUE_CALL_3(target, method, p1type, p1value, p2type, p2value, p3type, p3value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value); \ + target->method(p1value, p2value, p3value); \ } -#define QUEUE_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value , ...) \ +#define QUEUE_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value, (p4type) p4value); \ + target->method(p1value, p2value, p3value, p4value); \ } -#define QUEUE_CALL_5(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value , p5type, p5value , ...) \ +#define QUEUE_CALL_5(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, p5type, p5value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); SCHK_ARG(4, target, method, p5type, p5value); \ if (true) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value), Q_ARG(p5type, p5value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value, (p4type) p4value, (p5type) p5value); \ + target->method(p1value, p2value, p3value, p4value, p5value); \ } #define BLOCK_CALL_0(target, method, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection); \ else \ @@ -143,52 +201,57 @@ inline void SAFE_CALL_TEST_FUN() {}; #define BLOCK_CALL_1(target, method, p1type, p1value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_ARG(p1type, p1value)); \ else \ - target->method((p1type) p1value); \ + target->method(p1value); \ } #define BLOCK_CALL_2(target, method, p1type, p1value, p2type, p2value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value)); \ else \ - target->method((p1type) p1value, (p2type) p2value); \ + target->method(p1value, p2value); \ } #define BLOCK_CALL_3(target, method, p1type, p1value, p2type, p2value, p3type, p3value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value); \ + target->method(p1value, p2value, p3value); \ } -#define BLOCK_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value , ...) \ +#define BLOCK_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value, (p4type) p4value); \ + target->method(p1value, p2value, p3value, p4value); \ } #define BLOCK_CALL_5(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, p5type, p5value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); SCHK_ARG(4, target, method, p5type, p5value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::BlockingQueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value), Q_ARG(p5type, p5value)); \ else \ - target->method((p1type) p1value, (p2type) p2value, (p3type) p3value, (p4type) p4value, (p5type) p5value); \ + target->method(p1value, p2value, p3value, p4value, p5value); \ } #define AUTO_CALL_0(target, method, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection); \ else \ @@ -197,7 +260,8 @@ inline void SAFE_CALL_TEST_FUN() {}; #define AUTO_CALL_1(target, method, p1type, p1value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value)); \ else \ @@ -206,7 +270,8 @@ inline void SAFE_CALL_TEST_FUN() {}; #define AUTO_CALL_2(target, method, p1type, p1value, p2type, p2value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value)); \ else \ @@ -215,16 +280,18 @@ inline void SAFE_CALL_TEST_FUN() {}; #define AUTO_CALL_3(target, method, p1type, p1value, p2type, p2value, p3type, p3value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value)); \ else \ target->method(p1value, p2value, p3value); \ } -#define AUTO_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value , ...) \ +#define AUTO_CALL_4(target, method, p1type, p1value, p2type, p2value, p3type, p3value, p4type, p4value, ...) \ { \ - SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + hyperhdr::macros::SAFE_CALL_TEST_FUN(__VA_ARGS__); \ + SCHK_ARG(0, target, method, p1type, p1value); SCHK_ARG(1, target, method, p2type, p2value); SCHK_ARG(2, target, method, p3type, p3value); SCHK_ARG(3, target, method, p4type, p4value); \ if (target->thread() != QThread::currentThread()) \ QMetaObject::invokeMethod(target, #method, Qt::QueuedConnection, Q_ARG(p1type, p1value), Q_ARG(p2type, p2value), Q_ARG(p3type, p3value), Q_ARG(p4type, p4value)); \ else \ diff --git a/sources/api/HyperAPI.cpp b/sources/api/HyperAPI.cpp index aa2dd65a2..de1cc6be3 100644 --- a/sources/api/HyperAPI.cpp +++ b/sources/api/HyperAPI.cpp @@ -510,13 +510,13 @@ void HyperAPI::handleCropCommand(const QJsonObject& message, const QString& comm { GrabberWrapper* grabberWrapper = (_videoGrabber != nullptr) ? _videoGrabber->grabberWrapper() : nullptr; const QJsonObject& adjustment = message["crop"].toObject(); - int l = adjustment["left"].toInt(0); - int r = adjustment["right"].toInt(0); - int t = adjustment["top"].toInt(0); - int b = adjustment["bottom"].toInt(0); + unsigned l = static_cast(adjustment["left"].toInt(0)); + unsigned r = static_cast(adjustment["right"].toInt(0)); + unsigned t = static_cast(adjustment["top"].toInt(0)); + unsigned b = static_cast(adjustment["bottom"].toInt(0)); if (grabberWrapper != nullptr) - grabberWrapper->setCropping(l, r, t, b); + QUEUE_CALL_4(grabberWrapper,setCropping, unsigned, l, unsigned, r, unsigned, t, unsigned, b); sendSuccessReply(command, tan); } diff --git a/sources/base/ComponentController.cpp b/sources/base/ComponentController.cpp index e067d4360..a708b1f8b 100644 --- a/sources/base/ComponentController.cpp +++ b/sources/base/ComponentController.cpp @@ -43,8 +43,9 @@ void ComponentController::handleCompStateChangeRequest(hyperhdr::Components comp Debug(_log, "Disabling HyperHDR instance: saving current component states first"); _componentStates[COMP_ALL] = false; + auto componentStatesCopy = _componentStates; for (int i = 0; i < 2; i++) - for (const auto& comp : _componentStates) + for (const auto& comp : componentStatesCopy) if (comp.first != COMP_ALL && ((i == 0 && comp.first == COMP_LEDDEVICE) || (i == 1 && comp.first != COMP_LEDDEVICE))) { @@ -126,7 +127,16 @@ void ComponentController::turnGrabbers(bool activated, bool includingSystemGrabb auto currentStatusIsEnabled = isComponentEnabled(component); if (!_prevGrabbers.contains(component)) { - Info(_log, "Saving {:s} state {:s} before stopping", componentToIdString(component), (currentStatusIsEnabled) ? "ON" : "OFF"); + if (_prevComponentStates.contains(component)) + { + currentStatusIsEnabled = _prevComponentStates[component]; + _prevComponentStates.erase(component); + Info(_log, "Component {:s} state {:s} was already saved when the instance was disabled. The value is now taken over by the grabber’s own resume procedure", componentToIdString(component), (currentStatusIsEnabled) ? "ON" : "OFF"); + } + else + { + Info(_log, "Saving {:s} state {:s} before stopping", componentToIdString(component), (currentStatusIsEnabled) ? "ON" : "OFF"); + } _prevGrabbers.emplace(component, currentStatusIsEnabled); } if (currentStatusIsEnabled) diff --git a/sources/base/Grabber.cpp b/sources/base/Grabber.cpp index 787ad14c7..048cc9e64 100644 --- a/sources/base/Grabber.cpp +++ b/sources/base/Grabber.cpp @@ -994,7 +994,7 @@ void Grabber::setAutomaticToneMappingConfig(bool enabled, const AutomaticToneMap { _automaticToneMapping.setConfig(enabled, newConfig, timeInSec, timeToDisableInMSec); if (_automaticToneMapping.prepare() && !_qframe) - Error(_log, "Automatic tone mapping requires 'Quarter of frame' mode enabled"); + Error(_log, "Automatic tone mapping requires 'Scale frame size to 25%' mode enabled"); if (_automaticToneMapping.prepare() && (_enc != PixelFormat::YUYV && _enc != PixelFormat::NV12 && _enc != PixelFormat::P010 )) Warning(_log, "Automatic tone mapping requires YUYV/NV12/P010 video format"); diff --git a/sources/base/HyperHdrInstance.cpp b/sources/base/HyperHdrInstance.cpp index 59b5b84de..d5ff7ddfd 100644 --- a/sources/base/HyperHdrInstance.cpp +++ b/sources/base/HyperHdrInstance.cpp @@ -141,11 +141,11 @@ void HyperHdrInstance::start() connect(_muxer.get(), &Muxer::SignalPrioritiesChanged, this, &HyperHdrInstance::SignalPrioritiesChanged); connect(_muxer.get(), &Muxer::SignalVisiblePriorityChanged, this, &HyperHdrInstance::SignalVisiblePriorityChanged); connect(_muxer.get(), &Muxer::SignalVisibleComponentChanged, this, &HyperHdrInstance::SignalVisibleComponentChanged); - _infinite = std::make_unique(this); + _infinite = std::make_unique(this, _ledString.colorOrder); + Info(_log, "Led strip RGB order is: {:s}", (LedString::colorOrderToString(_ledString.colorOrder))); _ledGridSize = LedString::getLedLayoutGridSize(getSetting(settings::type::LEDS).array()); _currentLedColors = QVector(_ledString.leds().size(), ColorRgb::BLACK); - - Info(_log, "Led strip RGB order is: {:s}", (LedString::colorOrderToString(_ledString.colorOrder))); + connect(_instanceConfig.get(), &InstanceConfig::SignalInstanceSettingsChanged, this, &HyperHdrInstance::SignalInstanceSettingsChanged); @@ -166,7 +166,7 @@ void HyperHdrInstance::start() _ledDeviceWrapper = std::make_unique(this); connect(this, &HyperHdrInstance::SignalRequestComponent, _ledDeviceWrapper.get(), &LedDeviceWrapper::handleComponentState); - _ledDeviceWrapper->createLedDevice(ledDevice, _infinite->getSuggestedInterval(), _disableOnStartup); + _ledDeviceWrapper->createLedDevice(ledDevice, _infinite->getSuggestedInterval(), _infinite->getAntiFlickeringFilterState(), _disableOnStartup); // create the effect engine; needs to be initialized after smoothing! _effectEngine = std::make_unique(this); @@ -246,7 +246,7 @@ void HyperHdrInstance::handleSettingsUpdate(settings::type type, const QJsonDocu // do always reinit until the led devices can handle dynamic changes dev["currentLedCount"] = _hwLedCount; // Inject led count info - _ledDeviceWrapper->createLedDevice(dev, _infinite->getSuggestedInterval(), false); + _ledDeviceWrapper->createLedDevice(dev, _infinite->getSuggestedInterval(), _infinite->getAntiFlickeringFilterState(), false); } else if (type == settings::type::BGEFFECT || type == settings::type::FGEFFECT) { diff --git a/sources/base/InstanceConfig.cpp b/sources/base/InstanceConfig.cpp index 0bab2d8a9..2cfcdc683 100644 --- a/sources/base/InstanceConfig.cpp +++ b/sources/base/InstanceConfig.cpp @@ -222,9 +222,19 @@ bool InstanceConfig::upgradeDB(QJsonObject& dbConfig) colorObject["channelAdjustment"] = newArray; dbConfig["color"] = colorObject; /////////////////////////////////////////////////////////// - version = 5; - Info(_log, "DB has been upgraded to version: {:d}", version); + version = 5; + } + } + + if (version < 6) + { + if (!generalObject["disableOnLocked"].toBool()) + { + Info(_log, "Enabling disableOnLocked for better compatibility with software grabbers"); + generalObject["disableOnLocked"] = true; } + version = 6; + Info(_log, "DB has been upgraded to version: {:d}", version); } generalObject["version"] = version; diff --git a/sources/base/schema/schema-general.json b/sources/base/schema/schema-general.json index 0edda76b8..9cb4d945a 100644 --- a/sources/base/schema/schema-general.json +++ b/sources/base/schema/schema-general.json @@ -38,7 +38,7 @@ "type" : "boolean", "format": "checkbox", "title" : "edt_conf_gen_disableOnLocked_title", - "default" : false, + "default" : true, "required" : true, "propertyOrder" : 5 }, diff --git a/sources/base/schema/schema-smoothing.json b/sources/base/schema/schema-smoothing.json index eaac816c1..6c1c393dc 100644 --- a/sources/base/schema/schema-smoothing.json +++ b/sources/base/schema/schema-smoothing.json @@ -118,6 +118,15 @@ }, "propertyOrder" : 8 }, + "antiFlickeringFilter" : + { + "type" : "boolean", + "format": "checkbox", + "title" : "edt_conf_smooth_antiFlickeringFilter_title", + "default" : true, + "required" : true, + "propertyOrder" : 9 + }, "continuousOutput" : { "type" : "boolean", diff --git a/sources/flatbuffers/server/FlatBuffersServer.cpp b/sources/flatbuffers/server/FlatBuffersServer.cpp index 118ec97d7..c6e9c0c76 100644 --- a/sources/flatbuffers/server/FlatBuffersServer.cpp +++ b/sources/flatbuffers/server/FlatBuffersServer.cpp @@ -154,7 +154,7 @@ void FlatBuffersServer::handleSettingsUpdate(settings::type type, const QJsonDoc _quarterOfFrameMode = obj["quarterOfFrameMode"].toBool(false); Info(_log, "Tone mapping: {:d}", _flatbufferToneMappingMode); - Info(_log, "NV12 quarter of frame mode: {:d}", _quarterOfFrameMode); + Info(_log, "Scale NV12 frame size to 25%: {:d}", _quarterOfFrameMode); } } diff --git a/sources/grabber/linux/pipewire/CMakeLists.txt b/sources/grabber/linux/pipewire/CMakeLists.txt index 462e3e2d5..2e18bca77 100644 --- a/sources/grabber/linux/pipewire/CMakeLists.txt +++ b/sources/grabber/linux/pipewire/CMakeLists.txt @@ -14,7 +14,6 @@ target_link_libraries(smart-pipewire PUBLIC image sdbus-c++ ) -set_property(TARGET smart-pipewire PROPERTY CXX_STANDARD 17) # Grabber FILE ( GLOB PIPEWIRE_SOURCES "${CURRENT_HEADER_DIR}/smartPipewire.h" "${CURRENT_HEADER_DIR}/PipewireGrabber.h" "${CURRENT_HEADER_DIR}/PipewireWrapper.h" diff --git a/sources/grabber/windows/DX/DxGrabber.cpp b/sources/grabber/windows/DX/DxGrabber.cpp index 4fb16ee39..1ce8c25fa 100644 --- a/sources/grabber/windows/DX/DxGrabber.cpp +++ b/sources/grabber/windows/DX/DxGrabber.cpp @@ -388,7 +388,7 @@ bool DxGrabber::initDirectX(QString selectedDeviceName) pOutput6->GetDesc1(&descGamut); display->wideGamut = descGamut.ColorSpace == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020; - Info(_log, "Gamut: {:s}, min nits: %0.2f, max nits: %0.2f, max frame nits: %0.2f, white point: [%0.2f, %0.2f]", + Info(_log, "Gamut: {:s}, min nits: {:0.2f}, max nits: {:0.2f}, max frame nits: {:0.2f}, white point: [{:0.2f}, {:0.2f}]", std::string_view((display->wideGamut) ? "HDR" : "SDR"), descGamut.MinLuminance, descGamut.MaxLuminance, descGamut.MaxFullFrameLuminance, descGamut.WhitePoint[0], descGamut.WhitePoint[1]); diff --git a/sources/hyperhdr/HyperHdrDaemon.cpp b/sources/hyperhdr/HyperHdrDaemon.cpp index ed1328fa6..fbb71da47 100644 --- a/sources/hyperhdr/HyperHdrDaemon.cpp +++ b/sources/hyperhdr/HyperHdrDaemon.cpp @@ -1,3 +1,30 @@ +/* HyperHdrDaemon.cpp +* +* MIT License +* +* Copyright (c) 2020-2026 awawa-dev +* +* Project homesite: https://github.com/awawa-dev/HyperHDR +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. + +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +* SOFTWARE. + */ + #ifndef PCH_ENABLED #include #include @@ -189,7 +216,9 @@ void HyperHdrDaemon::instanceStateChangedHandler(InstanceState state, quint8 /*i if (_suspendHandler == nullptr) { QJsonObject genConfig = getSetting(settings::type::GENERAL).object(); - bool lockedEnable = genConfig["disableOnLocked"].toBool(false); + bool lockedEnable = genConfig["disableOnLocked"].toBool(true); + + Info(_log, "The OS lock/display‑suspend handler for the software grabber is: {:s}", ((lockedEnable) ? "enabled" : "disabled")); _suspendHandler = std::make_unique(lockedEnable); connect(_suspendHandler.get(), &SuspendHandler::SignalHibernate, _instanceManager.get(), &HyperHdrManager::hibernate); diff --git a/sources/infinite-color-engine/CoreInfiniteEngine.cpp b/sources/infinite-color-engine/CoreInfiniteEngine.cpp index fe29888c2..64d5f7d41 100644 --- a/sources/infinite-color-engine/CoreInfiniteEngine.cpp +++ b/sources/infinite-color-engine/CoreInfiniteEngine.cpp @@ -2,7 +2,7 @@ * * MIT License * -* Copyright (c) 2020-2025 awawa-dev +* Copyright (c) 2020-2026 awawa-dev * * Project homesite: https://github.com/awawa-dev/HyperHDR * @@ -33,10 +33,10 @@ using namespace hyperhdr; using namespace ColorSpaceMath; using namespace linalg::aliases; -CoreInfiniteEngine::CoreInfiniteEngine(HyperHdrInstance* hyperhdr) +CoreInfiniteEngine::CoreInfiniteEngine(HyperHdrInstance* hyperhdr, LedString::ColorOrder colorOrder) : QObject(), _smoothing(std::make_unique(hyperhdr->getSetting(settings::type::SMOOTHING), hyperhdr)), - _processing(std::make_unique(hyperhdr->getSetting(settings::type::COLOR), QString("COLORS%1").arg(hyperhdr->getInstanceIndex()))), + _processing(std::make_unique(hyperhdr->getSetting(settings::type::COLOR), colorOrder, QString("COLORS%1").arg(hyperhdr->getInstanceIndex()))), _log(QString("ENGINE%1").arg(hyperhdr->getInstanceIndex())) { qRegisterMetaType("SharedOutputColors"); @@ -52,6 +52,11 @@ int CoreInfiniteEngine::getSuggestedInterval() return _smoothing->getSuggestedInterval(); } +bool CoreInfiniteEngine::getAntiFlickeringFilterState() +{ + return _smoothing->getAntiFlickeringFilterState(); +} + unsigned CoreInfiniteEngine::addCustomSmoothingConfig(unsigned cfgID, int settlingTime_ms, double ledUpdateFrequency_hz, bool pause) { return _smoothing->addCustomSmoothingConfig(cfgID, settlingTime_ms, ledUpdateFrequency_hz, pause); @@ -65,7 +70,7 @@ void CoreInfiniteEngine::setCurrentSmoothingConfigParams(unsigned cfgID) void CoreInfiniteEngine::incomingColors(std::vector&& _ledBuffer) { _processing->applyyAllProcessingSteps(_ledBuffer); - _smoothing->incomingColors(std::move(_ledBuffer)); + _smoothing->incomingColors(std::move(_ledBuffer), _processing->getMinimalBacklight()); } void CoreInfiniteEngine::setProcessingEnabled(bool enabled) diff --git a/sources/infinite-color-engine/InfiniteExponentialInterpolator.cpp b/sources/infinite-color-engine/InfiniteExponentialInterpolator.cpp index 496b09f0a..8df91a768 100644 --- a/sources/infinite-color-engine/InfiniteExponentialInterpolator.cpp +++ b/sources/infinite-color-engine/InfiniteExponentialInterpolator.cpp @@ -90,7 +90,10 @@ void InfiniteExponentialInterpolator::setTargetColors(std::vector&& new_ void InfiniteExponentialInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } float dt = currentTimeMs - _lastUpdate; float kOrg = std::min(std::max(1.0f - std::exp(-dt / _tau), 0.0001f), 1.0f); @@ -147,7 +150,7 @@ void InfiniteExponentialInterpolator::updateCurrentColors(float currentTimeMs) } -SharedOutputColors InfiniteExponentialInterpolator::getCurrentColors() +SharedOutputColors InfiniteExponentialInterpolator::getCurrentColors(float /*minBrightness*/) { return std::make_shared>>(_currentColorsRGB); } diff --git a/sources/infinite-color-engine/InfiniteHybridInterpolator.cpp b/sources/infinite-color-engine/InfiniteHybridInterpolator.cpp index 30591c961..38f2f6926 100644 --- a/sources/infinite-color-engine/InfiniteHybridInterpolator.cpp +++ b/sources/infinite-color-engine/InfiniteHybridInterpolator.cpp @@ -74,7 +74,7 @@ void InfiniteHybridInterpolator::setTargetColors(std::vector&& new_rgb_t if (new_rgb_to_yuv_targets.empty()) return; - const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f; + const float delta = (!_isAnimationComplete) ? std::clamp(startTimeMs - _lastUpdate, 0.f, 100.0f) : 0.f; if (debug) { @@ -111,9 +111,12 @@ void InfiniteHybridInterpolator::setTargetColors(std::vector&& new_rgb_t void InfiniteHybridInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } - float dt = std::max(currentTimeMs - _lastUpdate, 0.001f); + float dt = std::clamp(currentTimeMs - _lastUpdate, 0.001f, 100.0f); _lastUpdate = currentTimeMs; auto computeChannelVec = [&](float3& cur, const float3& diff, float3& vel) -> bool { @@ -163,7 +166,7 @@ void InfiniteHybridInterpolator::updateCurrentColors(float currentTimeMs) { _currentColorsRGB.reset(); } -SharedOutputColors InfiniteHybridInterpolator::getCurrentColors() +SharedOutputColors InfiniteHybridInterpolator::getCurrentColors(float minBrightness) { if (!_currentColorsRGB.has_value()) { @@ -178,7 +181,7 @@ SharedOutputColors InfiniteHybridInterpolator::getCurrentColors() _currentColorsYUV.begin(), _currentColorsYUV.end(), tmp.begin(), - [](const auto& yuv) { return linalg::clamp(ColorSpaceMath::bt709_to_rgb(yuv), 0.f, 1.0f); } + [minBrightness](const auto& yuv) { return linalg::clamp(ColorSpaceMath::bt709_to_rgb(yuv), minBrightness, 1.0f); } ); _currentColorsRGB = std::move(tmp); } diff --git a/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp b/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp index 46aa42a84..05e0169f9 100644 --- a/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp +++ b/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp @@ -74,7 +74,7 @@ void InfiniteHybridRgbInterpolator::setTargetColors(std::vector&& new_rg if (new_rgb_targets.empty()) return; - const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f; + const float delta = (!_isAnimationComplete) ? std::clamp(startTimeMs - _lastUpdate, 0.f, 100.0f) : 0.f; if (debug) { @@ -118,9 +118,12 @@ void InfiniteHybridRgbInterpolator::setTargetColors(std::vector&& new_rg void InfiniteHybridRgbInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } - float dt = std::max(currentTimeMs - _lastUpdate, 0.001f); + float dt = std::clamp(currentTimeMs - _lastUpdate, 0.001f, 100.0f); _lastUpdate = currentTimeMs; auto computeChannelVec = [&](float3& cur, const float3& tgt, const float3& diff, float3& vel) -> bool { @@ -159,13 +162,13 @@ void InfiniteHybridRgbInterpolator::updateCurrentColors(float currentTimeMs) { } } -SharedOutputColors InfiniteHybridRgbInterpolator::getCurrentColors() +SharedOutputColors InfiniteHybridRgbInterpolator::getCurrentColors(float minBrightness) { auto result = std::make_shared>>(); result->reserve(_currentColorsRGB.size()); for (const auto& rgb : _currentColorsRGB) - result->push_back(linalg::clamp(rgb, 0.f, 1.f)); + result->push_back(linalg::clamp(rgb, minBrightness, 1.f)); return result; } diff --git a/sources/infinite-color-engine/InfiniteProcessing.cpp b/sources/infinite-color-engine/InfiniteProcessing.cpp index 754c0d098..c5aa9d4bf 100644 --- a/sources/infinite-color-engine/InfiniteProcessing.cpp +++ b/sources/infinite-color-engine/InfiniteProcessing.cpp @@ -81,10 +81,11 @@ InfiniteProcessing::InfiniteProcessing() : { } -InfiniteProcessing::InfiniteProcessing(const QJsonDocument& config, const LoggerName& log) : +InfiniteProcessing::InfiniteProcessing(const QJsonDocument& config, LedString::ColorOrder colorOrder, const LoggerName& log) : InfiniteProcessing() { _log = log; + _colorOrder = colorOrder; handleSignalInstanceSettingsChanged(settings::type::COLOR, config); } @@ -164,6 +165,7 @@ void InfiniteProcessing::handleSignalInstanceSettingsChanged(settings::type type if (type == settings::type::DEVICE) { _colorOrder = LedString::stringToColorOrder(config["colorOrder"].toString("rgb")); + Info(_log, "Current active RGB order is: {:s}", (config["colorOrder"].toString("rgb"))); } else if (type == settings::type::COLOR) { @@ -230,6 +232,11 @@ void InfiniteProcessing::applyyAllProcessingSteps(std::vector InfiniteProcessing::getMinimalBacklight() +{ + return _minimalBacklight; +} + void InfiniteProcessing::setMinimalBacklight(float minimalLevel, bool coloreBacklight) { if (minimalLevel >= 1.0f) @@ -530,9 +537,9 @@ void InfiniteProcessing::setTemperature(TemperaturePreset preset, linalg::vec&& new_rgb_targ if (new_rgb_targets.empty()) return; - const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f; + const float delta = (!_isAnimationComplete) ? std::clamp(startTimeMs - _lastUpdate, 0.f, 100.0f) : 0.f; if (debug) { @@ -114,7 +114,10 @@ void InfiniteRgbInterpolator::setSmoothingFactor(float factor) void InfiniteRgbInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } // obliczenie czasu, analog setupAdvColor float deltaTime = _targetTime - currentTimeMs; @@ -172,7 +175,7 @@ void InfiniteRgbInterpolator::updateCurrentColors(float currentTimeMs) } } -SharedOutputColors InfiniteRgbInterpolator::getCurrentColors() +SharedOutputColors InfiniteRgbInterpolator::getCurrentColors(float /*minBrightness*/) { return std::make_shared>>(_currentColorsRGB); } diff --git a/sources/infinite-color-engine/InfiniteSmoothing.cpp b/sources/infinite-color-engine/InfiniteSmoothing.cpp index 2e64ae654..d2d7f2eb4 100644 --- a/sources/infinite-color-engine/InfiniteSmoothing.cpp +++ b/sources/infinite-color-engine/InfiniteSmoothing.cpp @@ -2,7 +2,7 @@ * * MIT License * -* Copyright (c) 2020-2025 awawa-dev +* Copyright (c) 2020-2026 awawa-dev * * Project homesite: https://github.com/awawa-dev/HyperHDR * @@ -76,7 +76,9 @@ InfiniteSmoothing::InfiniteSmoothing(const QJsonDocument& config, HyperHdrInstan _infoUpdate(true), _infoInput(true), _coolDown(SMOOTHING_COOLDOWN_PHASE), - _lastSentFrame(0) + _lastSentFrame(0), + _antiFlickeringFilter(false), + _minimalBacklight(0.f) { // init cfg 0 (SMOOTHING_USER_CONFIG) addConfig(DEFAUL_SETTLINGTIME, DEFAUL_UPDATEFREQUENCY); @@ -147,7 +149,7 @@ void InfiniteSmoothing::clearQueuedColors(bool deviceEnabled, bool restarting) connect(this, &InfiniteSmoothing::SignalMasterClockTick, this, &InfiniteSmoothing::updateLeds, Qt::DirectConnection); } - emit _hyperhdr->SignalSmoothingRestarted(this->getSuggestedInterval()); + emit _hyperhdr->SignalSmoothingRestarted(this->getSuggestedInterval(), this->getAntiFlickeringFilterState()); Info(_log, "Smoothing queue is cleared"); } @@ -174,6 +176,7 @@ void InfiniteSmoothing::handleSignalInstanceSettingsChanged(settings::type type, } _continuousOutput = obj["continuousOutput"].toBool(true); + _antiFlickeringFilter = obj["antiFlickeringFilter"].toBool(true); _configurations[SMOOTHING_USER_CONFIG] = std::make_unique( SmoothingConfig{ @@ -190,9 +193,9 @@ void InfiniteSmoothing::handleSignalInstanceSettingsChanged(settings::type type, const auto& cfg = _configurations[SMOOTHING_USER_CONFIG]; Info(_log, "Updating user config ({:d}) => type: {:s}, pause: {:s}, settlingTime: {:d}ms, interval: {:d}ms ({:d}Hz)" - ", smoothingFactor: {:f}, stiffness: {:f}, damping: {:f}, y_limit: {:f}", + ", antiFlickeringFilter: {:s}, smoothingFactor: {:f}, stiffness: {:f}, damping: {:f}, y_limit: {:f}", SMOOTHING_USER_CONFIG, (EnumSmoothingTypeToString(cfg->type)), (cfg->pause) ? "true" : "false", int(cfg->settlingTime), int(cfg->updateInterval), int(1000.0 / cfg->updateInterval), - cfg->smoothingFactor, cfg->stiffness, cfg->damping, cfg->y_limit + ((_antiFlickeringFilter) ? "enabled": "disabled"), cfg->smoothingFactor, cfg->stiffness, cfg->damping, cfg->y_limit ); if (_currentConfigId == SMOOTHING_USER_CONFIG) @@ -204,8 +207,10 @@ void InfiniteSmoothing::handleSignalInstanceSettingsChanged(settings::type type, } } -void InfiniteSmoothing::incomingColors(std::vector&& nonlinearRgbColors) +void InfiniteSmoothing::incomingColors(std::vector&& nonlinearRgbColors, std::optional minimalBacklight) { + _minimalBacklight = (minimalBacklight.has_value()) ? minimalBacklight.value() : 0.f; + if (_infoInput) { if (!isEnabled()) @@ -245,7 +250,7 @@ void InfiniteSmoothing::updateLeds() timeNow = InternalClock::now(); _interpolator->updateCurrentColors(timeNow); - nonlinearRgbColors = _interpolator->getCurrentColors(); + nonlinearRgbColors = _interpolator->getCurrentColors(_minimalBacklight); if (!_interpolator->isAnimationComplete()) { @@ -343,6 +348,11 @@ int InfiniteSmoothing::getSuggestedInterval() return (isEnabled()) ? static_cast(_configurations[_currentConfigId]->updateInterval) : 0; } +bool InfiniteSmoothing::getAntiFlickeringFilterState() +{ + return _antiFlickeringFilter; +} + bool InfiniteSmoothing::selectConfig(unsigned cfgId) { bool result = (cfgId < (unsigned)_configurations.size()); @@ -353,13 +363,14 @@ bool InfiniteSmoothing::selectConfig(unsigned cfgId) const auto& cfg = _configurations[_currentConfigId]; - Info(_log, "Selecting config ({:d}) => type: {:s}, pause: {:s}, settlingTime: {:d}ms, interval: {:d}ms ({:d}Hz). Smoothing is currently: {:s}" + Info(_log, "Selecting config ({:d}) => type: {:s}, pause: {:s}, settlingTime: {:d}ms, interval: {:d}ms ({:d}Hz). Smoothing is currently: {:s} and antiFlickeringFilter is: {:s}" ", smoothingFactor: {:f}, stiffness: {:f}, damping: {:f}, y_limit: {:f}", _currentConfigId, (EnumSmoothingTypeToString(cfg->type)), (!cfg->pause) ? "true" : "false", int(cfg->settlingTime), int(cfg->updateInterval), int(1000.0 / cfg->updateInterval), (_enabled) ? "enabled" : "disabled", + ((_antiFlickeringFilter) ? "enabled" : "disabled"), cfg->smoothingFactor, cfg->stiffness, cfg->damping, cfg->y_limit); return result; diff --git a/sources/infinite-color-engine/InfiniteStepperInterpolator.cpp b/sources/infinite-color-engine/InfiniteStepperInterpolator.cpp index 7b426080a..de5865c47 100644 --- a/sources/infinite-color-engine/InfiniteStepperInterpolator.cpp +++ b/sources/infinite-color-engine/InfiniteStepperInterpolator.cpp @@ -64,7 +64,7 @@ void InfiniteStepperInterpolator::setTargetColors(std::vector&& new_rgb_ if (new_rgb_targets.empty()) return; - const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f; + const float delta = (!_isAnimationComplete) ? std::clamp(startTimeMs - _lastUpdate, 0.f, 100.0f) : 0.f; if (debug) { @@ -93,7 +93,10 @@ void InfiniteStepperInterpolator::setTargetColors(std::vector&& new_rgb_ void InfiniteStepperInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } // obliczenie czasu, analog setupAdvColor float deltaTime = _targetTime - currentTimeMs; @@ -152,7 +155,7 @@ void InfiniteStepperInterpolator::updateCurrentColors(float currentTimeMs) } -SharedOutputColors InfiniteStepperInterpolator::getCurrentColors() +SharedOutputColors InfiniteStepperInterpolator::getCurrentColors(float /*minBrightness*/) { return std::make_shared>>(_currentColorsRGB); } diff --git a/sources/infinite-color-engine/InfiniteYuvInterpolator.cpp b/sources/infinite-color-engine/InfiniteYuvInterpolator.cpp index 147e1cdd9..ad5cdf997 100644 --- a/sources/infinite-color-engine/InfiniteYuvInterpolator.cpp +++ b/sources/infinite-color-engine/InfiniteYuvInterpolator.cpp @@ -78,7 +78,7 @@ void InfiniteYuvInterpolator::setTargetColors(std::vector&& new_rgb_to_y if (new_rgb_to_yuv_targets.empty()) return; - const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f; + const float delta = (!_isAnimationComplete) ? std::clamp(startTimeMs - _lastUpdate, 0.f, 100.0f) : 0.f; if (debug) { @@ -128,7 +128,10 @@ void InfiniteYuvInterpolator::setTargetColors(std::vector&& new_rgb_to_y void InfiniteYuvInterpolator::updateCurrentColors(float currentTimeMs) { if (_isAnimationComplete) + { + _lastUpdate = currentTimeMs; return; + } // obliczenie czasu, analog setupAdvColor float deltaTime = _targetTime - currentTimeMs; @@ -175,7 +178,7 @@ void InfiniteYuvInterpolator::updateCurrentColors(float currentTimeMs) _currentColorsRGB.reset(); } -SharedOutputColors InfiniteYuvInterpolator::getCurrentColors() +SharedOutputColors InfiniteYuvInterpolator::getCurrentColors(float minBrightness) { if (!_currentColorsRGB.has_value()) { @@ -190,7 +193,7 @@ SharedOutputColors InfiniteYuvInterpolator::getCurrentColors() _currentColorsYUV.begin(), _currentColorsYUV.end(), tmp.begin(), - [](const auto& yuv) { return linalg::clamp(ColorSpaceMath::bt709_to_rgb(yuv), 0.f, 1.0f); } + [minBrightness](const auto& yuv) { return linalg::clamp(ColorSpaceMath::bt709_to_rgb(yuv), minBrightness, 1.0f); } ); _currentColorsRGB = std::move(tmp); } diff --git a/sources/led-drivers/LedDevice.cpp b/sources/led-drivers/LedDevice.cpp index 5d4d4eef3..d68a93a7d 100644 --- a/sources/led-drivers/LedDevice.cpp +++ b/sources/led-drivers/LedDevice.cpp @@ -1,3 +1,30 @@ +/* LedDevice.cpp +* +* MIT License +* +* Copyright (c) 2020-2026 awawa-dev +* +* Project homesite: https://github.com/awawa-dev/HyperHDR +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. + +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +* SOFTWARE. + */ + #ifndef PCH_ENABLED #include #include @@ -34,11 +61,13 @@ LedDevice::LedDevice(const QJsonObject& deviceConfig, QObject* parent) , _isDeviceReady(false) , _isOn(false) , _isDeviceInError(false) + , _antiFlickeringFilter(false) , _maxRetry(60) , _currentRetry(0) , _retryTimer(nullptr) , _isRefreshEnabled(false) , _newFrame2Send(false) + , _lastFinityLedValues(std::make_shared>()) , _blinkIndex(-1) , _blinkTime(0) , _instanceIndex(-1) @@ -263,6 +292,7 @@ void LedDevice::enableDevice(bool toEmit) { if (switchOn()) { + _lastFinityLedValues->clear(); _isDeviceReady = true; _isEnabled = true; stopRetryTimer(); @@ -303,6 +333,8 @@ void LedDevice::disableDevice(bool toEmit) if (_isRefreshEnabled) this->stopRefreshTimer(); + _lastFinityLedValues->clear(); + switchOff(); close(); @@ -335,6 +367,8 @@ bool LedDevice::init(QJsonObject deviceConfig) _defaultInterval = deviceConfig["refreshTime"].toInt(0); _forcedInterval = deviceConfig["forcedRefreshTime"].toInt(0); _smoothingInterval = deviceConfig["smoothingRefreshTime"].toInt(0); + _antiFlickeringFilter = deviceConfig["smoothingAntiFlickeringFilter"].toBool(false); + Debug(_log, "SetAntiFlickeringFilter: {:s}", ((_antiFlickeringFilter) ? "enabled" : "disabled")); setLedCount(deviceConfig["currentLedCount"].toInt(1)); // property injected to reflect real led count setRefreshTime(deviceConfig["refreshTime"].toInt(_currentInterval)); @@ -438,7 +472,7 @@ int LedDevice::hasLedClock() return _forcedInterval; } -void LedDevice::smoothingRestarted(int newSmoothingInterval) +void LedDevice::smoothingRestarted(int newSmoothingInterval, bool antiflickeringfilter) { if (_smoothingInterval != newSmoothingInterval) { @@ -447,6 +481,12 @@ void LedDevice::smoothingRestarted(int newSmoothingInterval) setRefreshTime(_defaultInterval); Debug(_log, "LED refresh interval adjustment caused by smoothing configuration change to {:d}ms (proposed: {:d}ms)", _currentInterval, newSmoothingInterval); } + + if (_antiFlickeringFilter != antiflickeringfilter) + { + _antiFlickeringFilter = antiflickeringfilter; + Debug(_log, "SetAntiFlickeringFilter: {:s}", ((_antiFlickeringFilter) ? "enabled" : "disabled")); + } } void LedDevice::handleSignalFinalOutputColorsReady(SharedOutputColors infinityLedColors) @@ -585,6 +625,35 @@ int LedDevice::write(SharedOutputColors nonlinearRgbColors) if (auto res = writeInfiniteColors(nonlinearRgbColors); !res.first) { + // finity output using antiflickering filter + if (_antiFlickeringFilter) + { + if (nonlinearRgbColors->size() == _lastFinityLedValues->size()) + { + std::vector ledValues; + ledValues.reserve(nonlinearRgbColors->size()); + + for (size_t i = 0; i < nonlinearRgbColors->size(); ++i) { + auto& oldV = (*_lastFinityLedValues)[i]; + const auto& newV = (*nonlinearRgbColors)[i]; + + if (linalg::maxelem(linalg::abs(newV - oldV) * 255.0f) > 0.49f) + { + oldV = newV; + } + + auto b = ColorSpaceMath::round_to_0_255(oldV * 255.0f); + ledValues.push_back({ b.x, b.y, b.z }); + } + return writeFiniteColors(ledValues); + } + else + { + *_lastFinityLedValues = *nonlinearRgbColors; + } + } + + // default finity output std::vector ledValues; ledValues.reserve(nonlinearRgbColors->size()); std::transform(nonlinearRgbColors->cbegin(), nonlinearRgbColors->cend(), std::back_inserter(ledValues), @@ -594,6 +663,12 @@ int LedDevice::write(SharedOutputColors nonlinearRgbColors) }); return writeFiniteColors(ledValues); } + else if (_antiFlickeringFilter) + { + _antiFlickeringFilter = false; + Warning(_log, "AntiFlickeringFilter was requested to be enabled, but the {:s} LED driver supports deep color and does not need it, so it is being disabled.", _activeDeviceType); + return res.second; + } else return res.second; } diff --git a/sources/led-drivers/LedDeviceWrapper.cpp b/sources/led-drivers/LedDeviceWrapper.cpp index eb02c8ca1..2a530de03 100644 --- a/sources/led-drivers/LedDeviceWrapper.cpp +++ b/sources/led-drivers/LedDeviceWrapper.cpp @@ -28,7 +28,7 @@ LedDeviceWrapper::~LedDeviceWrapper() _ledDevice.reset(); } -void LedDeviceWrapper::createLedDevice(QJsonObject config, int smoothingInterval, bool disableOnStartup) +void LedDeviceWrapper::createLedDevice(QJsonObject config, int smoothingInterval, bool antiFlickeringFilter, bool disableOnStartup) { auto threadReadyPromisePtr = std::make_shared>(); const int instanceIndex = _ownerInstance->getInstanceIndex(); @@ -36,6 +36,7 @@ void LedDeviceWrapper::createLedDevice(QJsonObject config, int smoothingInterval _ledDevice.reset(); config["smoothingRefreshTime"] = smoothingInterval; + config["smoothingAntiFlickeringFilter"] = antiFlickeringFilter; QThread* thread = new QThread(); thread->setObjectName(QString("LedDeviceThread%1").arg(instanceIndex)); @@ -61,7 +62,13 @@ void LedDeviceWrapper::createLedDevice(QJsonObject config, int smoothingInterval connect(_ledDevice.get(), &LedDevice::SignalEnableStateChanged, this, &LedDeviceWrapper::handleInternalEnableState, Qt::QueuedConnection); threadReadyPromisePtr->set_value(); - }, static_cast(Qt::SingleShotConnection | Qt::DirectConnection)); + }, + #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) + static_cast(Qt::SingleShotConnection | Qt::DirectConnection) + #else + Qt::DirectConnection + #endif + ); threadReadyPromisePtr->get_future().get(); } diff --git a/sources/led-drivers/net/ProviderUdpSSL.cpp b/sources/led-drivers/net/ProviderUdpSSL.cpp index e42afeb62..0e7ba76c9 100644 --- a/sources/led-drivers/net/ProviderUdpSSL.cpp +++ b/sources/led-drivers/net/ProviderUdpSSL.cpp @@ -157,6 +157,7 @@ bool ProviderUdpSSL::initNetwork() _dtls = new QDtls(QSslSocket::SslClientMode, this); _socket = new QUdpSocket(this); + _socket->bind(QHostAddress::AnyIPv4); _handshake_attempts_left = _handshake_attempts; QSslConfiguration config = QSslConfiguration::defaultDtlsConfiguration(); @@ -171,52 +172,51 @@ bool ProviderUdpSSL::initNetwork() this->setInError("Cannot initialize the neccesery ciphers. Please install OpenSSL 1.1.1 or higher (3.x)"); return false; } + allowedCiphers.append(cipher); }; config.setCiphers(allowedCiphers); - config.setPeerVerifyMode(QSslSocket::QueryPeer); + config.setProtocol(QSsl::DtlsV1_2); + config.setAllowedNextProtocols({}); + config.setPeerVerifyMode(QSslSocket::VerifyNone); _dtls->setDtlsConfiguration(config); _dtls->setPeer(_address, _ssl_port); connect(_dtls, &QDtls::pskRequired, this, &ProviderUdpSSL::pskRequired); connect(_dtls, &QDtls::handshakeTimeout, this, &ProviderUdpSSL::handshakeTimeout); - connect(_socket, &QUdpSocket::connected, this, [&]() { - if (_dtls != nullptr && _socket != nullptr) - { - Debug(_log, "Connected to the host. Initiating a handshake"); - _dtls->doHandshake(_socket); - } - }); connect(_socket, &QUdpSocket::errorOccurred, this, [&](QAbstractSocket::SocketError socketError) { QString message = QString("Socket error nr: %1").arg(QString::number(socketError)); QUEUE_CALL_1(this, errorHandling, QString, message); }); - connect(_socket, &QUdpSocket::readyRead, this, [&](){ + connect(_socket, &QUdpSocket::readyRead, this, [this](){ if (_dtls ==nullptr || _socket == nullptr || _socket->pendingDatagramSize() <= 0) return; - QByteArray dgram(_socket->pendingDatagramSize(), Qt::Uninitialized); - const qint64 bytesRead = _socket->readDatagram(dgram.data(), dgram.size()); - if (_dtls->isConnectionEncrypted() || bytesRead <= 0) - return; + while (_socket->hasPendingDatagrams()) { + QByteArray dgram(_socket->pendingDatagramSize(), Qt::Uninitialized); + const qint64 bytesRead = _socket->readDatagram(dgram.data(), dgram.size()); - Debug(_log, "Welcome datagram received. Proceeding with a handshake"); + if (_dtls->handshakeState() == QDtls::HandshakeComplete || _dtls->isConnectionEncrypted() || bytesRead <= 0) + continue; - dgram.resize(bytesRead); + Debug(_log, "Welcome datagram received. Proceeding with a handshake"); - if (!_dtls->doHandshake(_socket, dgram)) - { - QString message = "Failed to continue the handshake"; - QUEUE_CALL_1(this, errorHandling, QString, message); - return; - } + dgram.resize(bytesRead); - if (_dtls->isConnectionEncrypted()) - { - Debug(_log, "Established encrypted connection"); - _streamReady = true; + if (!_dtls->doHandshake(_socket, dgram)) + { + QString message = "Failed to continue the handshake"; + QUEUE_CALL_1(this, errorHandling, QString, message); + return; + } + + if (_dtls->isConnectionEncrypted()) + { + Debug(_log, "Established encrypted connection"); + _streamReady = true; + } } }); diff --git a/sources/suspend-handler/SuspendHandlerLinux.cpp b/sources/suspend-handler/SuspendHandlerLinux.cpp index b621f1081..ddd768e53 100644 --- a/sources/suspend-handler/SuspendHandlerLinux.cpp +++ b/sources/suspend-handler/SuspendHandlerLinux.cpp @@ -55,33 +55,36 @@ namespace { SuspendHandler::SuspendHandler(bool sessionLocker) { - try - { - auto monitorSignalHandler = [this](QString source, bool isOff) { - qDebug().nospace() << "Display event: monitor is " << (isOff ? "OFF" : "ON") << " (reporting: " << source << ")"; - emit SignalHibernate(!isOff, hyperhdr::SystemComponent::MONITOR); - }; - - _sessionBus = sdbus::createSessionBusConnection(); - _gnomeScreenSaverProxy = sdbus::createProxy(*_sessionBus, ServiceName{ GNOME_SERVICE }, ObjectPath{ GNOME_PATH }); - _gnomeScreenSaverProxy->uponSignal(SignalName{ "ActiveChanged" }).onInterface(InterfaceName{ GNOME_SERVICE }).call([monitorSignalHandler](bool active) { - monitorSignalHandler(QString(GNOME_SERVICE), active); - }); - _kdePowerProxy = sdbus::createProxy(*_sessionBus, ServiceName{ KDE_SERVICE }, ObjectPath{ KDE_PATH }); - _kdePowerProxy->uponSignal(SignalName{ "ActiveChanged" }).onInterface(InterfaceName{ KDE_SERVICE }).call([monitorSignalHandler](bool active) { - monitorSignalHandler(QString(KDE_SERVICE), active); - }); - _xfcePowerProxy = sdbus::createProxy(*_sessionBus, ServiceName{ XFCE_SERVICE }, ObjectPath{ XFCE_PATH }); - _xfcePowerProxy->uponSignal(SignalName{ "StateChanged" }).onInterface(InterfaceName{ XFCE_SERVICE }).call([monitorSignalHandler](uint32_t state) { - monitorSignalHandler(QString(XFCE_SERVICE), state == 3); - }); - _sessionBus->enterEventLoopAsync(); - - qDebug().nospace() << "THE MONITOR STATE HANDLER IS REGISTERED!"; - } - catch (std::exception& ex) + if (sessionLocker) { - qCritical().nospace() << "COULD NOT REGISTER MONITOR STATE HANDLER NEEDED BY, FOR EXAMPLE, PIPEWIRE GRABBER (WHICH WONT WORK AS A SERVICE): " << ex.what(); + try + { + auto monitorSignalHandler = [this](QString source, bool isOff) { + qDebug().nospace() << "Display event: monitor is " << (isOff ? "OFF" : "ON") << " (reporting: " << source << ")"; + emit SignalHibernate(!isOff, hyperhdr::SystemComponent::MONITOR); + }; + + _sessionBus = sdbus::createSessionBusConnection(); + _gnomeScreenSaverProxy = sdbus::createProxy(*_sessionBus, ServiceName{ GNOME_SERVICE }, ObjectPath{ GNOME_PATH }); + _gnomeScreenSaverProxy->uponSignal(SignalName{ "ActiveChanged" }).onInterface(InterfaceName{ GNOME_SERVICE }).call([monitorSignalHandler](bool active) { + monitorSignalHandler(QString(GNOME_SERVICE), active); + }); + _kdePowerProxy = sdbus::createProxy(*_sessionBus, ServiceName{ KDE_SERVICE }, ObjectPath{ KDE_PATH }); + _kdePowerProxy->uponSignal(SignalName{ "ActiveChanged" }).onInterface(InterfaceName{ KDE_SERVICE }).call([monitorSignalHandler](bool active) { + monitorSignalHandler(QString(KDE_SERVICE), active); + }); + _xfcePowerProxy = sdbus::createProxy(*_sessionBus, ServiceName{ XFCE_SERVICE }, ObjectPath{ XFCE_PATH }); + _xfcePowerProxy->uponSignal(SignalName{ "StateChanged" }).onInterface(InterfaceName{ XFCE_SERVICE }).call([monitorSignalHandler](uint32_t state) { + monitorSignalHandler(QString(XFCE_SERVICE), state == 3); + }); + _sessionBus->enterEventLoopAsync(); + + qDebug().nospace() << "THE MONITOR STATE HANDLER IS REGISTERED!"; + } + catch (std::exception& ex) + { + qCritical().nospace() << "COULD NOT REGISTER MONITOR STATE HANDLER NEEDED BY, FOR EXAMPLE, PIPEWIRE GRABBER (WHICH WONT WORK AS A SERVICE): " << ex.what(); + } } try diff --git a/www/i18n/cs.json b/www/i18n/cs.json index a6c450dc6..37f3712cc 100644 --- a/www/i18n/cs.json +++ b/www/i18n/cs.json @@ -10,13 +10,13 @@ "InfoDialog_lang_title": "Nastavení jazyka", "InfoDialog_nowrite_foottext": "WebUI se odemkne automaticky po vyřešení problému!", "InfoDialog_nowrite_text": "HyperHDR nemůže zapisovat do aktuálně načteného konfiguračního souboru. Chcete -li pokračovat, opravte oprávnění k souboru.", - "InfoDialog_nowrite_title": "chyba povolení zápisu!", + "InfoDialog_nowrite_title": "Chyba oprávnění k zápisu!", "about_3rd_party_licenses": "Licence třetích stran", "about_3rd_party_licenses_error": "Měli jsme problém se shromažďováním informací o licencích třetích stran z webu.
Použijte prosím tento odkaz na zdroj GitHub.", - "about_build": "Stavět", - "about_builddate": "Datum výstavby", + "about_build": "Zdroj sestavení", + "about_builddate": "Datum sestavení", "about_contribute": "Rozvíjejte HyperHDR s námi dále!", - "about_credits": "Kredity všem těmto vývojářům!", + "about_credits": "Poděkování všem těmto vývojářům!", "about_resources": "Knihovny $1", "about_translations": "Překlady", "about_version": "Verze", @@ -25,10 +25,10 @@ "conf_colors_smoothing_intro": "Vyhlazení vyrovnává změny barev/jasu, aby se omezilo rušivé rozptýlení. Nastavení frekvence aktualizace vyšší, než jsou možnosti ovladače LED pásku, může způsobit zpoždění a zúžení zpracování.", "conf_effect_bgeff_intro": "Definujte pozadová efekt/barvu, která se zobrazuje během \"nečinnosti\" HyperHDR. Vždy začíná s kanálem priority 255.", "conf_effect_fgeff_intro": "Definujte spouštěcí efekt nebo barvu, která se zobrazí při spuštění HyperHDR po definovanou dobu.", - "conf_effect_path_intro": "Zatěžovací efekty z definovaných cest. Kromě toho můžete deaktivovat jednotlivé efekty podle názvu a skrýt je ze všech seznamů efektů.", + "conf_effect_path_intro": "Načítání efektů z definovaných cest. Kromě toho můžete deaktivovat jednotlivé efekty podle názvu a skrýt je ze všech seznamů efektů.", "conf_general_createInst_btn": "Vytvořit instanci", - "conf_general_impexp_expbtn": "Vývozní", - "conf_general_impexp_impbtn": "Import", + "conf_general_impexp_expbtn": "Exportovat", + "conf_general_impexp_impbtn": "Importovat", "conf_general_impexp_l1": "Import/export konfigurační zálohy VŠECH instancí HyperHDR. Heslo pro přístup uživatele není uloženo, ale některá citlivá data mohou být obsažena v nastavení instance (například: přístupový klíč 'Philips Hue').", "conf_general_impexp_l2": "Formát souboru zálohy je kompatibilní s HyperHDR v17 a novějšími verzemi.", "conf_general_impexp_title": "Konfigurace importu/exportu", @@ -39,7 +39,7 @@ "conf_general_inst_name_title": "Název nové instance", "conf_general_inst_namehead": "Název instance", "conf_general_inst_renreq_t": "Do níže uvedeného pole zadejte nový název vaší instance.", - "conf_general_inst_title": "LED Hardware Instance Management", + "conf_general_inst_title": "Správa instancí LED hardwaru", "conf_general_intro": "Základní nastavení týkající se HyperHDR a WebUI, která nespadají do jiných kategorií.", "conf_general_label_title": "Obecné nastavení", "conf_grabber_fg_intro": "Zachycení platformy je zachycení vašeho místního systému jako vstupního zdroje, na kterém je nainstalován HyperHDR.", @@ -56,7 +56,7 @@ "conf_leds_layout_checkp2": "Rozložení je vždy přední pohled na vaši televizi, nikdy zadní pohled.", "conf_leds_layout_checkp3": "Ujistěte se, že je směr správný. Šedé LED diody indikují LED číslo 2 a 3 pro vizualizaci směru dat.", "conf_leds_layout_checkp4": "Případová mezera: Chcete -li vytvořit mezeru, nejprve ji při definování Nahoře/Dole/Vlevo/Vpravo ignorujte a poté nastavte délku mezery, abyste odstranili množství LED diod. Upravte pozici mezery, dokud se neshoduje.", - "conf_leds_layout_cl_bottom": "Dno", + "conf_leds_layout_cl_bottom": "Dole", "conf_leds_layout_cl_bottomleft": "Vlevo dole (roh)", "conf_leds_layout_cl_bottomright": "Vpravo dole (roh)", "conf_leds_layout_cl_cornergap": "Rohová mezera", @@ -75,7 +75,7 @@ "conf_leds_layout_cl_rightbottom": "Vpravo: 50 - 100% shora", "conf_leds_layout_cl_rightmiddle": "Vpravo: 25 - 75% shora", "conf_leds_layout_cl_righttop": "Vpravo: 0 - 50% shora", - "conf_leds_layout_cl_top": "Horní", + "conf_leds_layout_cl_top": "Nahoře", "conf_leds_layout_cl_topleft": "Vlevo nahoře (roh)", "conf_leds_layout_cl_topright": "Vpravo nahoře (roh)", "conf_leds_layout_cl_vleddepth": "Vertikální hloubka LED", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Zařízení pro zachytávání zvuku", "edt_conf_sound_device_expl": "Systémové zařízení pro zachytávání zvuku pro pluginy využívající vizualizaci hudby", "available_sound_devices": "Dostupná zařízení pro záznam zvuku", - "edt_conf_smooth_antiFlickeringTreshold_title": "Prahová hodnota proti blikání", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Přehrávače videa nebo komprimovaný videoobsah přinášejí při přehrávání filmů náhodný rozklad. Přestože změny hodnoty RGB mohou být malé, mohou u tmavých scén způsobit blikání v systému Ambilight. Například změna hodnoty RGB o 1-3 z rozkladu má malý vizuální efekt na jasné scény, ale při slabém osvětlení je to docela dramatické. Můžete povolit systém proti blikání pro režim slabého osvětlení a nastavit práh pro použití filtru, aby se předešlo takové situaci pro RGB pod takovou hodnotou. Světlých LED s RGB nad takovou prahovou hodnotou se filtr nedotkne. Funguje nejlépe s minimálním barevným podsvícením na kartě zpracování.
Pokud u statického/pozastaveného filmu dochází k blikání, váš problém má pravděpodobně elektrický charakter a tato možnost nepomůže. (0 = možnost je deaktivována, jinak navrhovaná hodnota je 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Minimální krok proti blikání", - "edt_conf_smooth_antiFlickeringValue_expl": "Minimální požadovaná změna barevného kanálu (připomenutí: plný rozsah RGB je 0-255 každý), kterého je třeba dosáhnout, aby ovlivnil zdroj LED. Cíl černé RGB (0,0,0) to vynechává, aby se zachovaly vypínací LED diody, pokud je vypnuto podsvícení", "main_ledsim_btn_screenshot": "Snímek obrazovky", "edt_conf_enum_linear_alternative": "Alternativní lineární (rychlejší)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Časový limit proti blikání", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Povolit změnu barvy LED diody RGB po vlastním čase v milisekundách, i když je krok pod minimem (0 = deaktivováno, jinak je navrhovaná hodnota alespoň 500, což dává 0.5 sekundy)", "dashboard_current_video_device": "Video zařízení", "dashboard_current_video_mode": "Režim videa", "general_comp_HDR": "HDR (globální)", @@ -1272,11 +1266,11 @@ "edt_conf_enum_cold": "Studená", "edt_conf_enum_neutral": "Neutrální", "edt_conf_enum_warm": "Teplá", - "edt_conf_enum_interpolator_Stepper_title": "Lineární interpolátor", + "edt_conf_enum_interpolator_Stepper_title": "Lineární Infinite Interpolátor", "edt_conf_enum_interpolator_Stepper_expl": "Lineární interpolátor je adaptací staršího algoritmu z předchozích verzí HyperHDR, přepsaného tak, aby používal aritmetiku s plovoucí desetinnou čárkou pro vyšší přesnost. Funguje tak, že lineárně interpoluje aktuální barvu směrem k cílové barvě, čímž zajišťuje, že přechod proběhne po definovanou dobu bez ohledu na snímkovou frekvenci. Jeho klíčovou charakteristikou je schopnost plynulého přesměrování uprostřed animace a zahájení nového, celodobého přechodu z aktuálního stavu směrem k novému cíli.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Nekonečný interpolátor RGB", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolátor RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Tento algoritmus plynule animuje barvy RGB po nastavenou dobu a nabízí dva odlišné režimy přechodu. Prvním je přímá lineární interpolace pro přímou cestu mezi barvami, zatímco druhým je vyhlazený režim, kde aktuální barva elegantně 'pronásleduje' cíl a vytváří efekt náběhu/odeznění. Klíčovou vlastností je jeho schopnost inteligentně změnit měřítko trvání animace při přerušení, čímž zajišťuje percepčně konstantní rychlost změny.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite Interpolator", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolátor YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Tento algoritmus plynule interpoluje barvy v barevném prostoru YUV pro percepčně jednotnější přechody. Jeho hlavní funkcí je omezení rychlosti změny jasu v každém kroku, čímž se zabrání náhlým, rušivým zábleskům jasu. To zajišťuje vizuálně příjemný efekt, i když animace trvá déle než původně nastavená doba trvání, aby se zachovala plynulost.", "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybridní fyzikální Infinite Interpolator (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Tento algoritmus plynule přechází mezi barvami pomocí hybridního fyzikálního modelu. Lineární 'chodník' definuje přímou cestu a načasování k cílové barvě, zatímco skutečná výstupní barva sleduje tento chodník jako objekt připojený k tlumené pružině. Tento dvoudílný přístup vytváří plynulé, přirozeně vypadající animace s přizpůsobitelnou setrvačností a překmitnutím, a to vše při provozu v percepčně jednotném barevném prostoru YUV.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Vynásobí barevné složky RGB daným faktorem v lineárním prostoru RGB.", "edt_conf_processing_powerLimit_title": "Omezení výstupního výkonu", "edt_conf_processing_powerLimit_expl": "Tato funkce kontroluje, zda byl překročen celkový odběr energie pro aktuální scénu. Pokud ano, automaticky sníží jas a barvu každé LED diody. Upozorňujeme, že se nejedná o náhradu dostatečně výkonného zdroje napájení. Tato funkce je navržena pouze k omezení nadměrného jasu a nechrání vaše zařízení před poškozením v důsledku poddimenzovaného zdroje napájení. Nezaručujeme, že se tato funkce přímo projeví omezením výkonu LED diod na určitou hodnotu výkonu.", - "edt_conf_smoothing_testMode_expl": "Cyklické náhlé změny barev pro testování algoritmů vyhlazování, výstup do konzole (ve Windows spusťte HyperHDR s parametrem -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponenciální nekonečný interpolátor", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponenciální interpolátor Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Klasická exponenciální implementace vyhlazování aktualizuje barvy LED diod směrem k cíli, rychle reaguje na velké rozdíly a zpomaluje, jak se k cíli přibližují, čímž vytváří plynulé a přirozené přechody mezi okolním osvětlením.", "edt_dev_spec_macAddress_title": "MAC adresa", "wiz_lifx_error": "Nepodařilo se najít zařízení Lifx. Zkontrolujte protokoly HyperHDR.", "wiz_lifx_title": "Průvodce světly LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Převést na lineární RGB" + "edt_dev_spec_convertToLinearRgb_title": "Převést na lineární RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtr proti blikání", + "edt_conf_smooth_antiFlickeringFilter_expl": "Povolí filtr silnika Infinite Color Engine, který snižuje jemné blikání LED způsobené 24bitovou kvantizací barev RGB. Ovladače podporující rozšířené formáty barev (deep color), jako je Philips Hue (v režimu Entertainment) nebo zařízení LIFX, tento filtr vůbec nepotřebují." } diff --git a/www/i18n/de.json b/www/i18n/de.json index 7187a9c8d..3b5a14218 100644 --- a/www/i18n/de.json +++ b/www/i18n/de.json @@ -13,8 +13,8 @@ "InfoDialog_nowrite_title": "Schreibberechtigungsfehler!", "about_3rd_party_licenses": "Lizenzen von Drittanbietern", "about_3rd_party_licenses_error": "Beim Sammeln von Lizenzinformationen von Drittanbietern aus dem Web sind Probleme aufgetreten.
Bitte folgen Sie diesem Link zur GitHub-Ressource.", - "about_build": "Build", - "about_builddate": "Erstellungsdatum", + "about_build": "Build-Quelle", + "about_builddate": "Kompilierungsdatum", "about_contribute": "Entwickeln Sie HyperHDR mit uns weiter!", "about_credits": "Dank an all diese Entwickler!", "about_resources": "$1 Bibliotheken", @@ -22,7 +22,7 @@ "about_version": "Version", "conf_colors_blackborder_intro": "Überspringen Sie schwarze Balken, wo immer sie sind. Jeder Modus verwendet einen anderen Erkennungsalgorithmus, der auf spezielle Situationen abgestimmt ist. Erhöhen Sie den Schwellenwert, wenn es für Sie nicht funktioniert.", "conf_colors_color_intro": "Erstellen Sie ein oder mehrere Kalibrierungsprofile, passen Sie jede Farbe, Helligkeit, Linearisierung und mehr an.", - "conf_colors_smoothing_intro": "Durch das Glätten werden Farb-/Helligkeitsänderungen abgeflacht, um störende Ablenkungen zu reduzieren. Wenn die Aktualisierungsfrequenz höher als die der LED-Streifen Treiberfähigkeiten eingestellt wird, kann dies zu Verzögerungen und Verarbeitungsengpässen führen.", + "conf_colors_smoothing_intro": "Durch das Glätten werden Farb-/Helligkeitsänderungen abgeflacht, um störende Ablenkungen zu reduzieren. Wenn die Aktualisierungsfrequenz höher als die der LED-Streifen-Treiberfähigkeiten eingestellt wird, kann dies zu Verzögerungen und Verarbeitungsengpässen führen.", "conf_effect_bgeff_intro": "Definieren Sie einen Hintergrundeffekt/Farbe, der während der HyperHDR-\"Ruhephase\" angezeigt wird. Beginnt immer mit dem Prioritätskanal 255.", "conf_effect_fgeff_intro": "Definieren Sie einen Start-Effekt oder eine Farbe, die während des HyperHDR-Starts für die definierte Dauer angezeigt wird.", "conf_effect_path_intro": "Effekte aus den definierten Pfaden laden. Zusätzlich können Sie einzelne Effekte namentlich deaktivieren, um sie aus allen Effektlisten auszublenden.", @@ -45,7 +45,7 @@ "conf_grabber_fg_intro": "Platform Capture ist Ihre lokale System Bilderfassung als Eingabequelle, auf der HyperHDR installiert ist.", "conf_grabber_video_intro": "Video Grabber ist ein Aufnahmegerät, das hauptsächlich über USB angeschlossen ist. Es stellt den aufgenommenen Videostream zur Verarbeitung bereit.", "conf_helptable_expl": "Erklärung", - "conf_helptable_option": "Funktion", + "conf_helptable_option": "Option", "conf_leds_contr_label_contrtype": "Controller-Typ:", "conf_leds_device_intro": "HyperHDR unterstützt viele Controller, um Daten an Ihr Zielgerät zu übertragen. Wählen Sie einen LED-Controller aus der sortierten Liste aus und konfigurieren Sie ihn. Wir haben für jedes Gerät die besten Standardeinstellungen ausgewählt.", "conf_leds_layout_advanced": "Erweiterte Einstellungen", @@ -56,12 +56,12 @@ "conf_leds_layout_checkp2": "Das Layout ist immer die Vorderansicht Ihres Fernsehers, niemals die Rückansicht.", "conf_leds_layout_checkp3": "Stellen Sie sicher, dass die Richtung stimmt. Die grauen LEDs zeigen die LED-Nummern 2 und 3 an, um die Datenrichtung zu visualisieren.", "conf_leds_layout_checkp4": "Gehäuselücke: Um eine Lücke zu erstellen, ignorieren Sie sie zuerst, wenn Sie Oben/Unten/Links/Rechts definieren, und stellen Sie anschließend Ihre Lückenlänge ein, um eine Anzahl von LEDs zu entfernen. Ändern Sie die Lückenposition, bis sie übereinstimmt.", - "conf_leds_layout_cl_bottom": "Unterseite", - "conf_leds_layout_cl_bottomleft": "Links, unten (Ecke)", - "conf_leds_layout_cl_bottomright": "Rechts, unten (Ecke)", + "conf_leds_layout_cl_bottom": "Unten", + "conf_leds_layout_cl_bottomleft": "Unten links (Ecke)", + "conf_leds_layout_cl_bottomright": "Unten rechts (Ecke)", "conf_leds_layout_cl_cornergap": "Ecklücke", "conf_leds_layout_cl_edgegap": "Randlücke", - "conf_leds_layout_cl_gaglength": "Spaltlänge", + "conf_leds_layout_cl_gaglength": "Lückenlänge", "conf_leds_layout_cl_gappos": "Lückenposition", "conf_leds_layout_cl_hleddepth": "Horizontale LED-Tiefe", "conf_leds_layout_cl_inppos": "Eingabeposition", @@ -75,9 +75,9 @@ "conf_leds_layout_cl_rightbottom": "Rechts: 50 - 100% von oben", "conf_leds_layout_cl_rightmiddle": "Rechts: 25 - 75% von oben", "conf_leds_layout_cl_righttop": "Rechts: 0 - 50% von oben", - "conf_leds_layout_cl_top": "Oberteil", - "conf_leds_layout_cl_topleft": "Oben, links (Ecke)", - "conf_leds_layout_cl_topright": "Oben, rechts (Ecke)", + "conf_leds_layout_cl_top": "Oben", + "conf_leds_layout_cl_topleft": "Oben links (Ecke)", + "conf_leds_layout_cl_topright": "Oben rechts (Ecke)", "conf_leds_layout_cl_vleddepth": "Vertikale LED-Tiefe", "conf_leds_layout_frame": "Klassisches Layout (LED-Rahmen)", "conf_leds_layout_generatedconf": "Generierte/aktuelle LED-Konfiguration", @@ -92,7 +92,7 @@ "conf_leds_layout_ma_opttopleft": "Oben links", "conf_leds_layout_ma_opttopright": "Oben rechts", "conf_leds_layout_ma_optvert": "Vertikal", - "conf_leds_layout_ma_order": "Befehl", + "conf_leds_layout_ma_order": "Reihenfolge", "conf_leds_layout_ma_position": "Eingang", "conf_leds_layout_ma_vert": "Vertikal", "conf_leds_layout_matrix": "Matrix-Layout (LED-Wand)", @@ -122,12 +122,12 @@ "leds_group_3_serial": "USB/Seriell", "conf_logging_btn_autoscroll": "Automatisches Scrollen", "conf_logging_btn_pbupload": "Laden Sie einen Bericht für Supportanfragen hoch", - "conf_logging_contpolicy": "Datenschutzrichtlinie melden", + "conf_logging_contpolicy": "Datenschutzbestimmungen", "conf_logging_label_intro": "Bereich zum Überprüfen von Protokollmeldungen, sehen Sie je nach eingestellter Protokollierungsstufe mehr oder weniger Informationen.", "conf_logging_lastreports": "Frühere Berichte", "conf_logging_nomessage": "Keine Protokollnachrichten verfügbar.", "conf_logging_report": "Prüfbericht", - "conf_logging_uplfailed": "Upload fehlgeschlagen! Bitte überprüfe deine Internetverbindung!", + "conf_logging_uplfailed": "Upload fehlgeschlagen! Bitte überprüfen Sie Ihre Internetverbindung!", "conf_logging_uploading": "Daten vorbereiten ...", "conf_logging_uplpolicy": "Durch Anklicken dieses Buttons akzeptieren Sie die", "conf_logging_yourlink": "Link zu Ihrem Bericht", @@ -231,7 +231,7 @@ "edt_conf_color_leds_expl": "Weisen Sie diese Einstellung allen LEDs (*) oder nur einigen (0-24) zu.", "edt_conf_color_magenta_title": "Magenta", "edt_conf_color_magenta_expl": "Der kalibrierte Magenta-Wert.", - "edt_conf_color_red_title": "rot", + "edt_conf_color_red_title": "Rot", "edt_conf_color_red_expl": "Der kalibrierte Rotwert.", "edt_conf_color_white_title": "Weiß", "edt_conf_color_white_expl": "Der kalibrierte Weißwert.", @@ -304,7 +304,7 @@ "edt_conf_fge_color_expl": "Wenn Typ \"Farbe\" ist, stellen Sie hier eine Farbe Ihrer Wahl ein.", "edt_conf_fge_duration_ms_title": "Dauer", "edt_conf_fge_duration_ms_expl": "Dauer von Effekt/Farbe während des Starts von HyperHDR.", - "edt_conf_fge_effect_title": "Wirkung", + "edt_conf_fge_effect_title": "Effekt", "edt_conf_fge_effect_expl": "Wenn der Typ \"Effekt\" ist, wählen Sie einen Effekt Ihrer Wahl (auch selbst erstellte Effekte).", "edt_conf_fge_heading_title": "Boot-Effekt", "edt_conf_fge_type_title": "Typ", @@ -357,7 +357,7 @@ "edt_conf_pbs_timeout_expl": "Wenn für den angegebenen Zeitraum keine Daten empfangen werden, wird die Komponente (weich) deaktiviert.", "edt_conf_smooth_continuousOutput_title": "Dauerleistung", "edt_conf_smooth_continuousOutput_expl": "Aktualisieren Sie die LEDs, auch wenn das Bild nicht geändert wurde.", - "edt_conf_smooth_decay_title": "Abschwell-Leistung", + "edt_conf_smooth_decay_title": "Abklingrate", "edt_conf_smooth_decay_expl": "Die Geschwindigkeit des Abschwellens. 1 ist linear, größere Werte haben eine stärkere Wirkung.", "edt_conf_smooth_dithering_title": "Dithering", "edt_conf_smooth_dithering_expl": "Verbessern Sie die Farbgenauigkeit bei hohen Ausgabegeschwindigkeiten, indem Sie zwischen benachbarten Farben wechseln.", @@ -806,7 +806,7 @@ "remote_input_sourceactiv_btn": "Quelle aktiv", "remote_input_status": "Status/Aktion", "remote_losthint": "Hinweis: Alle Änderungen gehen nach einem Neustart verloren.", - "remote_maptype_intro": "Normalerweise definiert das LED-Layout, welche LED einen bestimmten Bildbereich abdeckt, Sie können es hier ändern: $1", + "remote_maptype_intro": "Das LED‑Layout legt fest, welchen Bildbereich jede LED verwendet; hier können Sie den Algorithmus auswählen. $1", "remote_maptype_label": "Zuordnungstyp", "remote_maptype_label_multicolor_mean": "Mehrfarbig", "remote_maptype_label_unicolor_mean": "Einfarbig", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Tonaufnahmegerät", "edt_conf_sound_device_expl": "System-Soundaufnahmegerät für Plugins mit Musikvisualisierung", "available_sound_devices": "Verfügbare Tonaufnahmegeräte", - "edt_conf_smooth_antiFlickeringTreshold_title": "Anti-Flimmer-Schwellenwert", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Videoplayer oder komprimierte Videoinhalte führen beim Abspielen von Filmen zu zufälligem Dithering. Obwohl Änderungen des RGB-Werts gering sein können, können sie bei dunklen Szenen zu einem Flimmereffekt auf Ihrem Ambilight-System führen. Zum Beispiel hat das Ändern eines RGB-Werts um 1-3 von Dithering einen kleinen visuellen Effekt bei hellen Szenen, aber bei schwachem Licht ist es ziemlich dramatisch. Sie können das Antiflimmersystem für den Schwachlichtmodus aktivieren und einen Schwellenwert für die Anwendung eines Filters festlegen, um diese Situation für RGB unter diesem Wert zu vermeiden. Helle LEDs mit RGB über diesem Schwellenwert werden vom Filter nicht berührt. Funktioniert am besten mit farbiger, minimaler Hintergrundbeleuchtung im Verarbeitungs-Tab.
Wenn Sie bei einem statischen/pausierten Film Flackern bemerken, ist Ihr Problem wahrscheinlich elektrischer Natur und diese Option wird nicht helfen.(0 = die Option ist deaktiviert, andernfalls vorgeschlagener Wert ist 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Anti-Flimmern minimaler Schritt", - "edt_conf_smooth_antiFlickeringValue_expl": "Minimal erforderliche Änderung des Farbkanals (Erinnerung: der volle RGB-Bereich ist jeweils 0-255), die erreicht werden muss, um die LED-Quelle zu beeinflussen. RGB schwarzes Ziel (0,0,0) lässt dies aus, um das Ausschalten der LEDs zu erhalten, wenn die Hintergrundbeleuchtung deaktiviert ist", "main_ledsim_btn_screenshot": "Bildschirmfoto", "edt_conf_enum_linear_alternative": "Alternativ linear (schneller)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Anti-Flimmer-Timeout", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Erlauben Sie, eine RGB-LED-Farbe nach einer benutzerdefinierten Zeit in Millisekunden zu ändern, auch wenn der Schritt unter dem Minimum liegt (0 = deaktiviert, andernfalls beträgt der vorgeschlagene Wert mindestens 500, was 0.5 Sekunden ergibt)", "dashboard_current_video_device": "Videogerät", "dashboard_current_video_mode": "Video Modus", "general_comp_HDR": "HDR (global)", @@ -1067,9 +1061,9 @@ "lut_generator_main2": "Gammakorrektur für jeden Kanal. Nützlich, wenn Sie beispielsweise feststellen: zu viel Grün oder Ihr Bild ist zu dunkel und Ihr Grabber lässt keine Helligkeitssteuerung zu. Funktioniert bei aktivierter HDR-Tone-Mapping-Option.", "lut_generator_main3": "Minimaler Schwellenwert für jede RGB-Farbe (0-255). Bei einem Wert unter oder gleich wird die Einstellung als 0 betrachtet. Nützlich für Rauschen in dunklen Szenen und minimale Helligkeit aus der Bildverarbeitung.", "lut_generator_main4": "Gammakorrektur für jeden Kanal. Nützlich, wenn Sie beispielsweise feststellen: zu viel Grün oder Ihr Bild ist zu dunkel und Ihr Grabber lässt keine Helligkeitssteuerung zu. Funktioniert für YUV-Codecs (YUV/NV12/I420) ohne aktivierte HDR-Tone-Mapping-Option.", - "lut_generator_opt1_r": "Mindest. schwelle rot", - "lut_generator_opt1_g": "Mindest. Schwelle grün", - "lut_generator_opt1_b": "Mindest. Schwelle blau", + "lut_generator_opt1_r": "Mindestschwelle Rot", + "lut_generator_opt1_g": "Mindestschwelle Grün", + "lut_generator_opt1_b": "Mindestschwelle Blau", "lut_generator_opt2_r": "Gamma-Rot", "lut_generator_opt2_g": "Gammagrün", "lut_generator_opt2_b": "Gammablau", @@ -1222,8 +1216,8 @@ "edt_conf_monitor_nits_title": "HDR-Helligkeitskorrektur", "edt_conf_monitor_nits_expl": "SDR-Zielhelligkeit, die für die Konvertierung von HDR in SDR verwendet wird. Bei 0 wird die Hardware-Farbkonvertierung deaktiviert und gleichzeitig die beschleunigte Skalierung beibehalten.", "edt_append_nits": "nits", - "edt_conf_gen_disableOnLocked_title": "Deaktivieren, wenn gesperrt", - "edt_conf_gen_disableOnLocked_expl": "Schalten Sie die Verarbeitung aus, wenn der Benutzer das System gesperrt hat.", + "edt_conf_gen_disableOnLocked_title": "Deaktivieren bei gesperrtem System oder ausgeschaltetem Monitor", + "edt_conf_gen_disableOnLocked_expl": "Stoppt die Verarbeitung des Software‑Grabbers bei System­sperre oder ausgeschaltetem Monitor.", "edt_conf_gen_disableLedsStartup_title": "Schalten Sie die LEDs beim Start aus", "edt_conf_gen_disableLedsStartup_expl": "Deaktivieren Sie LEDs und alle Komponenten beim Start. Sie müssen sie manuell auf der Hauptseite oder über die JSON-API (COMP_ALL-Komponente) erneut aktivieren.", "edt_conf_sound_device_smoothing_title": "Glättung aktivieren", @@ -1233,12 +1227,12 @@ "option_calibration_classic": "Kalibrierung mit Windows mit aktiviertem HDR-Modus und einem Webbrowser.
Wir kalibrieren die LUT unter Berücksichtigung des Grabbers und Ihres Fernsehers.", "video_calibration_overview": "1 Sie müssen das Videoformat Ihres Grabbers auf MJPEG/YUV/NV12/P010 einstellen. Andere Formate werden nicht unterstützt.

2 Wenn Sie mit Flatbuffers kalibrieren, müssen Sie in den Einstellungen das Tone Mapping aktivieren. Nur das NV12-Videoformat wird unterstützt.

3 Sie können Testdateien hier herunterladen: Link. Starten Sie die Wiedergabe der Testdatei in Ihrem Player. Sie sollte in der HyperHDR-Videovorschau angezeigt werden. Der Testbildschirm muss den gesamten Bildschirm einnehmen und es dürfen keine überflüssigen Elemente, wie etwa das Playermenü, sichtbar sein.

4 Zur Kalibrierung sollten Sie eine Datei mit 'hdr' im Namen wählen, es sei denn, Ihr System oder Player verwendet automatisch SDR-zu-HDR-Tonmapping oder Sie planen, das SDR-Signal zu kalibrieren. Wählen Sie in diesem Fall zur Anpassung an ein solches Szenario eine Datei mit 'sdr' im Namen.

5 Das Format YUV420 mit begrenztem Bereich bietet die größte Kompatibilität mit durchschnittlicher bis sehr guter Qualität und ist das beliebteste. Das Format YUV444 bietet die beste Qualität, aber es ist selten, in diesem Format codierte Materialien zu finden.

6 Wenn Sie die Kalibrierung mit Windows 11 durchführen (mit einem Webbrowser oder Videoplayer als Videoquelle), deaktivieren Sie Funktionen wie 'Nachtlicht', 'Farbverwaltung für Apps automatisch' und 'Auto-HDR'. Ändern Sie den Farbabgleich im Grafiktreiber nicht. Die GFX-Ausgabe sollte z. B. 10 oder 12 Bit RGB im vollen PC-Bereich unterstützen.

7 Die Berechnungen sind sehr intensiv und belasten Ihre Ausrüstung! Sie können die LCH-Farbkorrektur deaktivieren, um die Belastung etwas zu reduzieren.", "chk_calibration_debug": "Debug", - "flatbuffers_nv12_quarter_of_frame_title": "Viertel des Frames für NV12", + "flatbuffers_nv12_quarter_of_frame_title": "Skalieren Sie die NV12‑Bildgröße auf 25%", "flatbuffers_nv12_quarter_of_frame_expl": "Der NV12-Codec enthält viermal mehr Informationen über Helligkeit als über Farbe. Mit dieser Option können Sie die CPU-Last reduzieren, indem Sie die Höhe und Breite des Video-Frames um 2 reduzieren, ohne Farbinformationen zu verlieren.", "chk_lchCorrection": "LCH-Farbkorrektur", "grabber_calibration_expl": "Mit diesem Tool können Sie eine neue kalibrierte HDR-LUT für Ihren Grabber (oder eine externe Flatbuffer-Quelle) erstellen, die den tatsächlichen Eingabefarben so nahe wie möglich kommt.
Sie benötigen eine HDR10-Videoquelle, die diese Webseite anzeigen kann, zum Beispiel: Windows 10 mit aktiviertem HDR in den Eigenschaften des Grafiktreibers.
Der Bildschirm kann während der Kalibrierung flimmern. Der Vorgang dauert auf einem Intel 7 Windows-PC normalerweise einige Minuten (abhängig von den CPU-Ressourcen des Hosts und der Bildrate der Videoaufnahme).
Die Berechnungen sind sehr intensiv und belasten Ihre Ausrüstung Sie können die LCH-Farbkorrektur deaktivieren, um die Belastung etwas zu reduzieren.
Sie können den Fortschritt in den HyperHDR-Protokollen mit dem Browser eines anderen Geräts überwachen.


1 Wenn alles richtig angeschlossen ist, sollte diese Seite auf dem Fernsehbildschirm angezeigt werden (als HDR-Inhalt) und eine Live-Vorschau in HyperHDR (aufgenommen vom Grabber).
2 Die absolute Mindestauflösung für die Aufnahme beträgt 1280x720 (wir werden dies überprüfen). Empfohlen wird 1920x1080 YUV/NV12. Das Seitenverhältnis 1920/1080 muss beibehalten werden.
3 Sie müssen den 'Skalieren Sie die Bildgröße auf 25%' in den Grabber-Eigenschaften deaktivieren, falls er aktiviert ist.
4 Sie müssen das Videoformat des Grabbers auf MJPEG/YUV/NV12/P010 einstellen.
5 Bevor Sie den Vorgang ausführen, schalten Sie Ihren WWW-Browser bitte in den Vollbildmodus (Taste F11, wir werden dies überprüfen).
6 Wenn Sie mit Windows 11 kalibrieren, deaktivieren Sie Funktionen wie 'Nachtlicht', 'Farbe für Apps automatisch verwalten' und 'Auto-HDR'. Ändern Sie den Farbabgleich im Grafiktreiber nicht. Die GFX-Ausgabe sollte z. B. unterstützen. 10 oder 12 Bit RGB im vollen PC-Bereich.

Nach Abschluss der Kalibrierung wird Ihre neue LUT-Tabellendatei (lut_lin_tables.3d) im HyperHDR-Stammverzeichnis des Benutzers erstellt und ist sofort einsatzbereit, wenn Sie einfach das HDR-Tonemapping aktivieren. Weitere Informationen finden Sie in den HyperHDR-Protokollen.", "edt_automatic_tone_mapping_title": "Automatisches Tone Mapping", - "edt_automatic_tone_mapping_enable_explain": "Die automatische Tone Mapping-Steuerung ist nur für 'YUV/NV12/P010'-Videoformate mit aktiviertem 'Viertelbild'-Modus verfügbar. Bitte konfigurieren Sie sie in den USB-Grabber-Einstellungen.
Die Komponente aktiviert das Tone Mapping automatisch, wenn das Signal die konfigurierten Schwellenwerte für einen bestimmten Zeitraum nicht überschreitet, und deaktiviert es sofort nach Überschreiten.
Später können Sie dann überprüfen, welcher Wert einen der Schwellenwerte überschritten hat, wodurch das Tone Mapping in den HyperHDR-Protokollen tatsächlich deaktiviert wurde. Und dann können Sie die Konfiguration möglicherweise anpassen, wenn sie falsche Ereignisse zur Deaktivierung des Tone Mappings generiert (Schwellenwert zu niedrig) oder unnötiges Aktivieren des Tone Mappings in dunklen SDR-Szenen generiert (Schwellenwert zu hoch).", + "edt_automatic_tone_mapping_enable_explain": "Die automatische Tone Mapping-Steuerung ist nur für 'YUV/NV12/P010'-Videoformate mit aktiviertem 'Skalieren Sie die Bildgröße auf 25%'-Modus verfügbar. Bitte konfigurieren Sie sie in den USB-Grabber-Einstellungen.
Die Komponente aktiviert das Tone Mapping automatisch, wenn das Signal die konfigurierten Schwellenwerte für einen bestimmten Zeitraum nicht überschreitet, und deaktiviert es sofort nach Überschreiten.
Später können Sie dann überprüfen, welcher Wert einen der Schwellenwerte überschritten hat, wodurch das Tone Mapping in den HyperHDR-Protokollen tatsächlich deaktiviert wurde. Und dann können Sie die Konfiguration möglicherweise anpassen, wenn sie falsche Ereignisse zur Deaktivierung des Tone Mappings generiert (Schwellenwert zu niedrig) oder unnötiges Aktivieren des Tone Mappings in dunklen SDR-Szenen generiert (Schwellenwert zu hoch).", "edt_automatic_tone_mapping_y_threshold_title": "Helligkeitsschwelle (Y)", "edt_automatic_tone_mapping_y_threshold_expl": "Der Helligkeitspegel, der dunkles HDR-Rohmaterial vom SDR-Signal trennt.", "edt_automatic_tone_mapping_u_threshold_title": "Blauer Chroma-Schwellenwert (U)", @@ -1274,14 +1268,14 @@ "edt_conf_enum_warm": "Warm", "edt_conf_enum_interpolator_Stepper_title": "Linearer Interpolator", "edt_conf_enum_interpolator_Stepper_expl": "Der lineare Interpolator ist eine Adaption eines Algorithmus aus früheren HyperHDR-Versionen, der für höhere Präzision Gleitkommaarithmetik verwendet. Er interpoliert die aktuelle Farbe linear in Richtung einer Zielfarbe und stellt so sicher, dass der Übergang unabhängig von der Bildrate über eine definierte Dauer abgeschlossen ist. Sein Hauptmerkmal ist die Fähigkeit, mitten in der Animation einen nahtlosen Übergang vom aktuellen Zustand zum neuen Ziel zu ermöglichen.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB-Infinite-Interpolator", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Infinite RGB-Interpolator", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Dieser Algorithmus animiert RGB-Farben über eine festgelegte Dauer und bietet zwei verschiedene Modi für den Übergang. Der erste ist eine direkte lineare Interpolation für einen geraden Pfad zwischen den Farben, während der zweite ein geglätteter Modus ist, bei dem die aktuelle Farbe der Zielfarbe sanft folgt und so einen Ease-In/Ease-Out-Effekt erzeugt. Ein wichtiges Merkmal ist die Fähigkeit, die Dauer einer Animation bei Unterbrechungen intelligent neu zu skalieren und so eine wahrnehmbar konstante Änderungsgeschwindigkeit zu gewährleisten.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV-Infinite-Interpolator", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Infinite YUV-Interpolator", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Dieser Algorithmus interpoliert Farben sanft im YUV-Farbraum und sorgt so für gleichmäßigere Übergänge. Seine Hauptfunktion ist die Begrenzung der Luminanzänderung in jedem Schritt, wodurch plötzliche, störende Helligkeitsschwankungen vermieden werden. Dies sorgt für einen optisch ansprechenden Effekt, selbst wenn die Animation über die ursprünglich festgelegte Dauer hinaus verlängert wird, um die Glätte zu erhalten.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Infinite-Interpolator (YUV)", - "edt_conf_enum_interpolator_HybridInterpolator_expl": "Dieser Algorithmus ermöglicht sanfte Farbübergänge mithilfe eines hybriden physikalischen Modells. Ein linearer 'Pacer' definiert den direkten Weg und das Timing zur Zielfarbe, während die eigentliche Ausgabefarbe diesem Pacer folgt, wie ein an einer gedämpften Feder befestigtes Objekt. Dieser zweiteilige Ansatz erzeugt flüssige, natürlich wirkende Animationen mit anpassbarer Trägheit und Überschwingen im wahrnehmungsmäßig gleichmäßigen YUV-Farbraum.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hybrid Physics Infinite-Interpolator (RGB)", - "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Dieser Algorithmus ermöglicht fließende Farbübergänge mithilfe eines hybriden physikalischen Modells. Ein linearer 'Schrittgeber' definiert den direkten Pfad und das Timing zur Zielfarbe, während die tatsächliche Ausgabefarbe diesem Schrittgeber wie ein an einer gedämpften Feder hängendes Objekt folgt. Dieser zweistufige Ansatz erzeugt flüssige, natürlich wirkende Animationen mit anpassbarer Trägheit und Überschwingen – und das alles im RGB-Farbraum.", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite Interpolator: Hybrid-Physik mit Trägheit (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_expl": "Dieser Algorithmus wechselt sanft zwischen Farben, indem er ein hybrides physikalisches Modell verwendet. Zuerst wird ein linearer Pfad sowie die Zeit bis zur Zielfarbe bestimmt, danach folgt die tatsächliche Ausgabefarbe diesem Pfad wie ein Objekt an einer gedämpften Feder. Dieser zweistufige Ansatz erzeugt flüssige, natürlich wirkende Animationen mit einstellbarer Trägheit und Überschwingen und arbeitet im wahrnehmungsuniformen YUV-Farbraum.", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite Interpolator: Hybrid-Physik mit Trägheit (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Dieser Algorithmus wechselt sanft zwischen Farben, indem er ein hybrides physikalisches Modell verwendet. Zuerst wird ein linearer Pfad sowie die Zeit bis zur Zielfarbe bestimmt, danach folgt die tatsächliche Ausgabefarbe diesem Pfad wie ein Objekt an einer gedämpften Feder. Dieser zweistufige Ansatz erzeugt flüssige, natürlich wirkende Animationen mit einstellbarer Trägheit und Überschwingen und arbeitet im RGB-Farbraum.", "edt_conf_enum_interpolator_smoothingFactor_title": "Glättungsfaktor", "edt_conf_enum_interpolator_smoothingFactor_expl": "Dieser Parameter bestimmt die Anmutung der Animation und steuert die Farbübergänge. Er akzeptiert Werte zwischen 0.0 und 1.0, wobei 0.0 eine direkte, lineare Änderung bewirkt. Höhere Werte führen zu einer stärkeren Glättung und erzeugen eine flüssige, jagende Bewegung, da die aktuelle Farbe leicht hinter der Idealposition zurückbleibt.", "edt_conf_enum_interpolator_stiffness_title": "Steifheit", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Multipliziert die RGB-Farbkomponenten mit einem bestimmten Faktor im linearen RGB-Raum.", "edt_conf_processing_powerLimit_title": "Leistungsbegrenzung", "edt_conf_processing_powerLimit_expl": "Diese Funktion prüft, ob die Gesamtleistungsaufnahme der aktuellen Szene überschritten wurde. Falls ja, werden Helligkeit und Farbe jeder LED automatisch reduziert. Bitte beachten Sie: Dies ist kein Ersatz für ein ausreichend leistungsstarkes Netzteil. Diese Funktion dient lediglich der Begrenzung übermäßiger Helligkeit und schützt Ihre Geräte nicht vor Schäden durch ein zu kleines Netzteil. Wir garantieren nicht, dass diese Funktion die Leistung des LED-Setups direkt auf einen bestimmten Wattwert begrenzt.", - "edt_conf_smoothing_testMode_expl": "Zyklische, plötzliche Farbänderungen zum Testen von Glättungsalgorithmen, Ausgabe in der Konsole (unter Windows HyperHDR mit dem Parameter -c ausführen).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponentieller Unendlicher Interpolator", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponentieller Infinite-Interpolator", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Die klassische exponentielle Implementierung der Glättung aktualisiert die LED-Farben in Richtung eines Ziels. Sie reagiert schnell auf große Unterschiede und verlangsamt sich bei Annäherung an das Ziel. Dadurch entstehen sanfte, natürliche Übergänge der Umgebungsbeleuchtung.", "edt_dev_spec_macAddress_title": "MAC-Adresse", "wiz_lifx_error": "LiFX-Geräte konnten nicht gefunden werden. Überprüfen Sie die HyperHDR-Protokolle.", "wiz_lifx_title": "LIFX-Lichtassistent", - "edt_dev_spec_convertToLinearRgb_title": "In lineares RGB umwandeln" + "edt_dev_spec_convertToLinearRgb_title": "In lineares RGB umwandeln", + "edt_conf_smooth_antiFlickeringFilter_title": "Anti‑Flimmer‑Filter", + "edt_conf_smooth_antiFlickeringFilter_expl": "Aktiviert einen Infinite Color Engine-Filter, der feines LED-Flimmern reduziert, das durch 24-Bit-RGB-Farbquantisierung verursacht wird. Controller, die erweiterte Farbformate unterstützen (Deep Color), wie Philips Hue (im Entertainment-Modus) lub LIFX-Geräte, benötigen diesen Filter nicht." } diff --git a/www/i18n/en.json b/www/i18n/en.json index 10df7a3f9..9cf757b90 100644 --- a/www/i18n/en.json +++ b/www/i18n/en.json @@ -13,7 +13,7 @@ "InfoDialog_nowrite_title": "write permission error!", "about_3rd_party_licenses": "3rd party licenses", "about_3rd_party_licenses_error": "We had trouble collecting 3rd party licenses information from web.
Please follow this link to the GitHub Resource.", - "about_build": "Build", + "about_build": "Build source", "about_builddate": "Build date", "about_contribute": "Develop HyperHDR further with us!", "about_credits": "Credits to all these developers!", @@ -806,7 +806,7 @@ "remote_input_sourceactiv_btn": "Source active", "remote_input_status": "Status/Action", "remote_losthint": "Note: All changes are lost after a restart.", - "remote_maptype_intro": "Usually the led layout defines which LED covers a specific picture area, you could change it here: $1", + "remote_maptype_intro": "The LED layout defines which part of the image each LED uses; here you can select the algorithm. $1", "remote_maptype_label": "Mapping type", "remote_maptype_label_multicolor_mean": "Multicolor", "remote_maptype_label_unicolor_mean": "Unicolor", @@ -1222,8 +1222,8 @@ "edt_conf_monitor_nits_title": "HDR brightness correction", "edt_conf_monitor_nits_expl": "SDR target brightness used for HDR to SDR conversion. If 0, it disables hardware color conversion while maintaining accelerated scaling.", "edt_append_nits": "nits", - "edt_conf_gen_disableOnLocked_title": "Disable when locked", - "edt_conf_gen_disableOnLocked_expl": "Turn off processing when the user has locked the system.", + "edt_conf_gen_disableOnLocked_title": "Disable on OS lock or monitor off", + "edt_conf_gen_disableOnLocked_expl": "Stops software grabber processing during OS lock or monitor‑off events. A restart is required for the changes to take effect.", "edt_conf_gen_disableLedsStartup_title": "Turn off LEDs at startup", "edt_conf_gen_disableLedsStartup_expl": "Disable LEDs and all components on startup, you must re-enable them manually on the main page or via the JSON API (COMP_ALL component).", "edt_conf_sound_device_smoothing_title": "Enable smoothing", @@ -1233,12 +1233,12 @@ "option_calibration_classic": "Calibration using Windows with HDR mode enabled and a web browser.
We calibrate LUT taking into account the grabber and your TV.", "video_calibration_overview": "1 You need to set the video format of your grabber to MJPEG/YUV/NV12/P010. Other formats are not supported.

2 If you calibrate using Flatbuffers, you need to enable tone mapping in its settings. Only the NV12 video format is supported.

3 You can download test files here: link. In your player, start playing the test file. You should see it in the HyperHDR video preview. The test screen must take up the entire screen and no extraneous elements, such as the player menu, can be visible.

4 For calibration, you should choose a file with 'hdr' in the name unless your system or player automatically uses SDR to HDR tone mapping or if you plan to calibrate the SDR signal. In that case, to adapt to such a scenario, choose a file with 'sdr' in the name.

5 The limited range YUV420 format provides the greatest compatibility with average to very good quality and is the most popular.. The YUV444 format provides the best quality but it is rare to find materials encoded in this form.

6 If you are calibrating using Windows 11 (using a web browser or video player as the video source), turn off features such as 'Night light', 'Automatic manage color for apps' and 'Auto-HDR'. Do not change the color balance in the graphics driver. The GFX output should support e.g. 10 or 12 bit RGB in full PC range.

7 The calculations are very intensive and put a strain on your equipment! You can disable LCH color correction to reduce the load a bit.", "chk_calibration_debug": "Debug", - "flatbuffers_nv12_quarter_of_frame_title": "Quarter of frame for NV12", + "flatbuffers_nv12_quarter_of_frame_title": "Scale NV12 frame size to 25%", "flatbuffers_nv12_quarter_of_frame_expl": "The NV12 codec contains four times more information about brightness than about color. This option allows you to reduce CPU load by reducing the height and width of the video frame by 2 without losing color information.", "chk_lchCorrection": "LCH color correction", "grabber_calibration_expl": "This tool allows you to create a new calibrated HDR LUT for your grabber (or external flatbuffers source) as close to the actual input colors as possible.
You need an HDR10 video source that can display this web page, for example: Windows 10 with HDR enabled in the properties of the graphics driver.
The screen may flicker during calibration. The process typically takes about few minutes on a Intel 7 Windows PC (depending on the host CPU resources and the video capturing framerate).
The calculations are very intensive and put a strain on your equipment You can disable LCH color correction to reduce the load a bit
You can monitor the progress in HyperHDR logs using the browser from other device.


1 If everything is properly connected, this page should be displayed on the TV screen (as HDR content) and live preview in HyperHDR (captured by the grabber).
2 Absolute minimum capturing resolution is 1280x720 (we will verify this). Recommended is 1920x1080 YUV/NV12. Aspect 1920/1080 must be preserved.
3 You must disable 'Scale frame size to 25%' in your grabber properties if it's enabled.
4 You must set the grabber's video format to MJPEG/YUV/NV12/P010.
5 Before you run the process please put your WWW browser in the full-screen mode (F11 key, we will verify this).
6 If you are calibrating using Windows 11, turn off features such as 'Night light', 'Automatic manage color for apps' and 'Auto-HDR'. Do not change the color balance in the graphics driver. The GFX output should support e.g. 10 or 12 bit RGB in full PC range.

After completing the calibration, your new LUT table file (lut_lin_tables.3d) will be created in the user's HyperHDR home directory and is immediately ready to use when you just enable HDR tone mapping. Please verify HyperHDR logs for details.", "edt_automatic_tone_mapping_title": "Automatic tone mapping", - "edt_automatic_tone_mapping_enable_explain": "Automatic tone mapping control is only available for 'YUV/NV12/P010' video formats with 'Quarter of frame' mode enabled. Please configure them in the USB grabber settings.
The component will automatically enable tone mapping if the signal does not exceed the configured threshold levels for a certain period of time, and will disable it immediately after exceeding them.
Then later you can check what was the value that exceeded any of the thresholds, which actually caused tone mapping to be disabled in HyperHDR logs. And then possibly adjust the configuration if it generates false events of tone mapping disabling (threshold too low) or generates unnecessary tone mapping enabling in dark SDR scenes (threshold too high).", + "edt_automatic_tone_mapping_enable_explain": "Automatic tone mapping control is only available for 'YUV/NV12/P010' video formats with 'Scale frame size to 25%' mode enabled. Please configure them in the USB grabber settings.
The component will automatically enable tone mapping if the signal does not exceed the configured threshold levels for a certain period of time, and will disable it immediately after exceeding them.
Then later you can check what was the value that exceeded any of the thresholds, which actually caused tone mapping to be disabled in HyperHDR logs. And then possibly adjust the configuration if it generates false events of tone mapping disabling (threshold too low) or generates unnecessary tone mapping enabling in dark SDR scenes (threshold too high).", "edt_automatic_tone_mapping_y_threshold_title": "Brightness threshold (Y)", "edt_automatic_tone_mapping_y_threshold_expl": "The brightness level that separates raw dark HDR material from the SDR signal.", "edt_automatic_tone_mapping_u_threshold_title": "Blue chroma threshold (U)", @@ -1278,9 +1278,9 @@ "edt_conf_enum_interpolator_RgbInterpolator_expl": "This algorithm smoothly animates RGB colors over a set duration, offering two distinct modes for the transition. The first is a direct linear interpolation for a straight path between colors, while the second is a smoothed mode where the current color gracefully 'chases' the target to create an ease-in/ease-out effect. A key feature is its ability to intelligently rescale an animation's duration when interrupted, ensuring a perceptually constant speed of change.", "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite Interpolator", "edt_conf_enum_interpolator_YuvInterpolator_expl": "This algorithm smoothly interpolates colors by operating in the YUV color space for more perceptually uniform transitions. Its main feature is limiting the rate of luminance change in each step, preventing sudden, jarring flashes of brightness. This ensures a visually pleasing effect, even if it extends the animation beyond its initially set duration to maintain that smoothness.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Infinite Interpolator (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite Interpolator: hybrid physics with inertia (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "This algorithm smoothly transitions between colors using a hybrid physical model. A linear 'pacer' defines the direct path and timing to the target color, while the actual output color follows this pacer like an object attached to a damped spring. This two-part approach creates fluid, natural-looking animations with customizable inertia and overshoot, all while operating in the perceptually-uniform YUV color space.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hybrid Physics Infinite Interpolator (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite Interpolator: hybrid physics with inertia (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "This algorithm smoothly transitions between colors using a hybrid physical model. A linear 'pacer' defines the direct path and timing to the target color, while the actual output color follows this pacer like an object attached to a damped spring. This two-part approach creates fluid, natural-looking animations with customizable inertia and overshoot, all while operating in the RGB color space.", "edt_conf_enum_interpolator_smoothingFactor_title": "Smoothing factor", "edt_conf_enum_interpolator_smoothingFactor_expl": "The parameter dictates the animation's feel, controlling how it transitions between colors. It accepts a value from 0.0 to 1.0, where 0.0 results in a direct, linear change. Higher values introduce more smoothing, creating a fluid 'chasing' motion as the current color lags slightly behind the ideal position.", @@ -1308,5 +1308,7 @@ "edt_dev_spec_macAddress_title": "MAC address", "wiz_lifx_error": "Could not find Lifx devices. Check HyperHDR logs.", "wiz_lifx_title": "LIFX lights wizard", - "edt_dev_spec_convertToLinearRgb_title": "Convert to linear RGB" + "edt_dev_spec_convertToLinearRgb_title": "Convert to linear RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Anti‑flicker filter", + "edt_conf_smooth_antiFlickeringFilter_expl": "Enables an infinite color engine filter that reduces subtle LED flickering caused by 24‑bit RGB color quantization. Controllers that support extended color formats (deep color), such as Philips Hue (in Entertainment mode) or LIFX devices, do not need this filter at all." } diff --git a/www/i18n/es.json b/www/i18n/es.json index ca977fb9f..22851a213 100644 --- a/www/i18n/es.json +++ b/www/i18n/es.json @@ -10,11 +10,11 @@ "InfoDialog_lang_title": "Configuración de idioma", "InfoDialog_nowrite_foottext": "¡La WebUI se desbloqueará automáticamente después de que haya resuelto el problema!", "InfoDialog_nowrite_text": "HyperHDR no puede escribir en su archivo de configuración cargado actual. Repare los permisos del archivo para continuar.", - "InfoDialog_nowrite_title": "error de permiso de escritura!", + "InfoDialog_nowrite_title": "¡Error de permiso de escritura!", "about_3rd_party_licenses": "Licencias de terceros", "about_3rd_party_licenses_error": "Tuvimos problemas para recopilar información de licencias de terceros desde la web.
Siga este enlace al recurso de GitHub.", - "about_build": "Construir", - "about_builddate": "La fecha de construcción", + "about_build": "Origen de compilación", + "about_builddate": "Fecha de compilación", "about_contribute": "¡Desarrolle HyperHDR aún más con nosotros!", "about_credits": "¡Créditos a todos estos desarrolladores!", "about_resources": "Bibliotecas de $1", @@ -57,8 +57,8 @@ "conf_leds_layout_checkp3": "Asegúrese de que la dirección sea la correcta. Los LED grises indican los LED número 2 y 3 para visualizar la dirección de los datos.", "conf_leds_layout_checkp4": "Case Gap: para crear un gap, ignórelo primero cuando defina Superior/Inferior/Izquierda/Derecha y luego configure la longitud del espacio para eliminar una cantidad de leds. Modifique la posición del espacio hasta que coincida.", "conf_leds_layout_cl_bottom": "Fondo", - "conf_leds_layout_cl_bottomleft": "Esquina izquierda inferior)", - "conf_leds_layout_cl_bottomright": "Esquina inferior derecha)", + "conf_leds_layout_cl_bottomleft": "Esquina inferior izquierda", + "conf_leds_layout_cl_bottomright": "Esquina inferior derecha", "conf_leds_layout_cl_cornergap": "Espacio en la esquina", "conf_leds_layout_cl_edgegap": "Espacio de borde", "conf_leds_layout_cl_gaglength": "Longitud de la brecha", @@ -76,8 +76,8 @@ "conf_leds_layout_cl_rightmiddle": "Derecha: 25 - 75% desde arriba", "conf_leds_layout_cl_righttop": "Derecha: 0 - 50% desde arriba", "conf_leds_layout_cl_top": "Cima", - "conf_leds_layout_cl_topleft": "Esquina superior izquierda)", - "conf_leds_layout_cl_topright": "Esquina superior derecha)", + "conf_leds_layout_cl_topleft": "Esquina superior izquierda", + "conf_leds_layout_cl_topright": "Esquina superior derecha", "conf_leds_layout_cl_vleddepth": "Profundidad de LED vertical", "conf_leds_layout_frame": "Diseño clásico (marco LED)", "conf_leds_layout_generatedconf": "Configuración de LED generados/actuales", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Dispositivo de captura de sonido", "edt_conf_sound_device_expl": "Dispositivo de captura de sonido del sistema para complementos que utilizan visualización de música", "available_sound_devices": "Dispositivos de captura de sonido disponibles", - "edt_conf_smooth_antiFlickeringTreshold_title": "Valor umbral anti-parpadeo", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Los reproductores de video o el contenido de video comprimido introducen un tramado aleatorio mientras se reproducen películas. Aunque los cambios en el valor RGB pueden ser pequeños, pueden causar un efecto de parpadeo en su sistema Ambilight en escenas oscuras. Por ejemplo, cambiar uno de los valores RGB en 1-3 de la interpolación tiene un pequeño efecto visual en escenas brillantes, pero con poca luz es bastante dramático. Puede habilitar el sistema anti-parpadeo para el modo de poca luz y establecer un umbral para aplicar el filtro para evitar esa situación para RGB por debajo de dicho valor. Los leds brillantes con RGB por encima de dicho umbral no son tocados por el filtro. Funciona mejor con luz de fondo mínima de color en la pestaña de procesamiento.
Si experimenta parpadeo en la película estática/en pausa, entonces su problema probablemente sea de naturaleza eléctrica y esa opción no ayudará. (0 = la opción está deshabilitada, de lo contrario valor propuesto es 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Paso mínimo anti-parpadeo", - "edt_conf_smooth_antiFlickeringValue_expl": "Cambio mínimo requerido del canal de color (recordatorio: el rango RGB completo es 0-255 cada uno) que debe alcanzarse para afectar la fuente de LED. El objetivo negro RGB (0,0,0) omite eso para mantener el apagado de los leds si la luz de fondo está desactivada", "main_ledsim_btn_screenshot": "Captura de pantalla", "edt_conf_enum_linear_alternative": "Lineal alternativo (más rápido)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Tiempo de espera anti-parpadeo", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Permitir cambiar un color de led RGB, después del tiempo personalizado en milisegundos, incluso si el paso está por debajo del mínimo (0 = deshabilitado, de lo contrario el valor propuesto es al menos 500 lo que da 0.5 segundos)", "dashboard_current_video_device": "Dispositivo de video", "dashboard_current_video_mode": "Modo de vídeo", "general_comp_HDR": "HDR (global)", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "Frío", "edt_conf_enum_neutral": "Neutro", "edt_conf_enum_warm": "Cálido", - "edt_conf_enum_interpolator_Stepper_title": "Interpolador Lineal", + "edt_conf_enum_interpolator_Stepper_title": "Interpolador Lineal Infinite", "edt_conf_enum_interpolator_Stepper_expl": "El Interpolador Lineal es una adaptación de un algoritmo heredado de versiones anteriores de HyperHDR, reescrito para usar aritmética de punto flotante para una mayor precisión. Funciona interpolando linealmente el color actual hacia un color objetivo, garantizando que la transición se complete durante un tiempo definido, independientemente de la velocidad de fotogramas. Su característica principal es la capacidad de redirigir suavemente la animación a mitad de camino, iniciando una nueva transición de duración completa desde su estado actual hacia el nuevo objetivo.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolador RGB Infinito", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolador RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Este algoritmo anima suavemente los colores RGB durante un tiempo determinado, ofreciendo dos modos distintos para la transición. El primero es una interpolación lineal directa para una trayectoria recta entre colores, mientras que el segundo es un modo suavizado donde el color actual 'persigue' elegantemente el objetivo para crear un efecto de entrada/salida gradual. Una característica clave es su capacidad para reescalar inteligentemente la duración de una animación al interrumpirse, garantizando una velocidad de cambio perceptualmente constante.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolador Infinito YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolador YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Este algoritmo interpola colores de forma fluida operando en el espacio de color YUV para lograr transiciones más uniformes desde el punto de vista perceptual. Su principal característica es limitar la velocidad de cambio de luminancia en cada paso, evitando destellos de brillo repentinos y bruscos. Esto garantiza un efecto visualmente agradable, incluso si se extiende la animación más allá de su duración inicial para mantener dicha fluidez.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolador Infinito de Física Híbrida (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolador Infinite de Física Híbrida (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Este algoritmo realiza transiciones fluidas entre colores utilizando un modelo físico híbrido. Un 'marcador' lineal define la trayectoria y la sincronización directas hacia el color objetivo, mientras que el color de salida real sigue este marcador como un objeto sujeto a un resorte amortiguado. Este enfoque en dos partes crea animaciones fluidas y de aspecto natural con inercia y sobreimpulso personalizables, todo ello operando en el espacio de color YUV perceptualmente uniforme.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolador Infinito de Física Híbrida (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolador Infinite de Física Híbrida (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Este algoritmo realiza transiciones fluidas entre colores mediante un modelo físico híbrido. Un 'marcador' lineal define la trayectoria y el ritmo directos hacia el color objetivo, mientras que el color de salida real sigue este marcador como un objeto sujeto a un resorte amortiguado. Este enfoque en dos partes crea animaciones fluidas y naturales con inercia y sobreimpulso personalizables, todo ello operando en el espacio de color RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Factor de suavizado", "edt_conf_enum_interpolator_smoothingFactor_expl": "Este parámetro determina la sensación de la animación, controlando la transición entre colores. Acepta un valor de 0.0 a 1.0, donde 0.0 produce un cambio directo y lineal. Valores más altos introducen un suavizado más intenso, creando un movimiento fluido de 'persecución' a medida que el color actual se retrasa ligeramente respecto a la posición ideal.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Multiplica los componentes de color RGB por un factor determinado en el espacio RGB lineal.", "edt_conf_processing_powerLimit_title": "Limitar la potencia de salida", "edt_conf_processing_powerLimit_expl": "Esta función comprueba si se ha excedido el consumo total de energía de la escena actual. De ser así, reduce automáticamente el brillo y el color de cada LED. Tenga en cuenta que esto no sustituye a una fuente de alimentación suficientemente potente. Esta función solo está diseñada para limitar el brillo excesivo y no protege su equipo de daños causados ​​por una fuente de alimentación insuficiente. No garantizamos que esta función limite directamente la potencia de la configuración LED a un valor de potencia específico.", - "edt_conf_smoothing_testMode_expl": "Cambios de color repentinos cíclicos para probar algoritmos de suavizado; salida a la consola (en Windows, ejecute HyperHDR con el parámetro -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolador exponencial infinito", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolador exponencial Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "La implementación exponencial clásica del suavizado actualiza los colores del LED hacia un objetivo, reaccionando rápidamente a grandes diferencias y ralentizándolos a medida que se acercan al objetivo, lo que produce transiciones de iluminación ambiental suaves y naturales.", "edt_dev_spec_macAddress_title": "Dirección MAC", "wiz_lifx_error": "No se encontraron dispositivos Lifx. Consulte los registros de HyperHDR.", "wiz_lifx_title": "Asistente de iluminación LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Convertir a RGB lineal" + "edt_dev_spec_convertToLinearRgb_title": "Convertir a RGB lineal", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtro antiparpadeo", + "edt_conf_smooth_antiFlickeringFilter_expl": "Activa un filtro de Infinite Color Engine que reduce el parpadeo sutil de los LED causado por la cuantificación de color RGB de 24 bits. Los controladores que admiten formatos de color extendidos (color profundo), como Philips Hue (en modo Entertainment) o los dispositivos LIFX, no necesitan este filtro en absoluto." } diff --git a/www/i18n/fr.json b/www/i18n/fr.json index 5855423f3..81550b567 100644 --- a/www/i18n/fr.json +++ b/www/i18n/fr.json @@ -10,14 +10,14 @@ "InfoDialog_lang_title": "Paramètres de langue", "InfoDialog_nowrite_foottext": "L'interface Web sera déverrouillée automatiquement une fois le problème résolu!", "InfoDialog_nowrite_text": "HyperHDR ne peut pas écrire dans votre fichier de configuration actuellement chargé. Veuillez réparer les autorisations de fichier pour continuer.", - "InfoDialog_nowrite_title": "erreur d'autorisation d'écriture!", + "InfoDialog_nowrite_title": "Erreur d'autorisation d'écriture!", "about_3rd_party_licenses": "Licences tierces", "about_3rd_party_licenses_error": "Nous avons eu du mal à collecter des informations sur les licences tierces à partir du Web.
Veuillez suivre ce lien vers la ressource GitHub.", - "about_build": "Construire", - "about_builddate": "Date de construction", - "about_contribute": "Développez HyperHDR plus loin avec nous !", + "about_build": "Source de compilation", + "about_builddate": "Date de compilation", + "about_contribute": "Contribuez au développement de HyperHDR!", "about_credits": "Remerciements à tous ces développeurs !", - "about_resources": "Bibliothèques à $1", + "about_resources": "Bibliothèques $1", "about_translations": "Traductions", "about_version": "Version", "conf_colors_blackborder_intro": "Ignorez les barres noires où qu'elles soient. Chaque mode utilise un autre algorithme de détection qui est réglé pour des situations spéciales. Augmentez le seuil si cela ne fonctionne pas pour vous.", @@ -32,7 +32,7 @@ "conf_general_impexp_l1": "Importez/exportez une sauvegarde de configuration de TOUTES les instances HyperHDR. Le mot de passe d'accès utilisateur n'est pas enregistré mais certaines données sensibles peuvent être contenues dans les paramètres de l'instance (par exemple: clé d'accès 'Philips Hue').", "conf_general_impexp_l2": "Le format de fichier de sauvegarde est compatible avec HyperHDR v17 et les versions ultérieures.", "conf_general_impexp_title": "Importer/Exporter la configuration", - "conf_general_inst_actionhead": "action", + "conf_general_inst_actionhead": "Action", "conf_general_inst_delreq_h": "Supprimer l'instance de matériel LED", "conf_general_inst_delreq_t": "Êtes-vous sûr de vouloir supprimer l'instance \"$1\"? Tous les paramètres seront également supprimés.", "conf_general_inst_desc": "Utilisez différents matériels LED en même temps. Chaque instance s'exécute indépendamment les unes des autres, ce qui permet différentes dispositions de LED et paramètres d'étalonnage. Les instances en cours d'exécution sont disponibles sur l'icône sur la gauche", @@ -58,18 +58,18 @@ "conf_leds_layout_checkp4": "Case Gap: Pour créer un écart, ignorez-le d'abord lorsque vous définissez Haut/Bas/Gauche/Droite et définissez ensuite la longueur de votre écart pour supprimer un certain nombre de leds. Modifiez la position de l'espace jusqu'à ce qu'elle corresponde.", "conf_leds_layout_cl_bottom": "Bas", "conf_leds_layout_cl_bottomleft": "En bas à gauche (coin)", - "conf_leds_layout_cl_bottomright": "Le coin inférieur droit)", + "conf_leds_layout_cl_bottomright": "En bas à droite (coin)", "conf_leds_layout_cl_cornergap": "Écart de coin", "conf_leds_layout_cl_edgegap": "Écart de bord", "conf_leds_layout_cl_gaglength": "Longueur de l'espace", "conf_leds_layout_cl_gappos": "position de l'écart", "conf_leds_layout_cl_hleddepth": "Profondeur de LED horizontale", "conf_leds_layout_cl_inppos": "Position d'entrée", - "conf_leds_layout_cl_left": "La gauche", + "conf_leds_layout_cl_left": "Gauche", "conf_leds_layout_cl_leftbottom": "Gauche: 50 - 100% à partir du haut", "conf_leds_layout_cl_leftmiddle": "Gauche: 25 - 75% à partir du haut", "conf_leds_layout_cl_lefttop": "Gauche: 0 - 50% à partir du haut", - "conf_leds_layout_cl_overlap": "Chevauchement", + "conf_leds_layout_cl_overlap": "Recouvrement", "conf_leds_layout_cl_reversdir": "Direction inverse", "conf_leds_layout_cl_right": "Droite", "conf_leds_layout_cl_rightbottom": "À droite: 50 - 100% à partir du haut", @@ -77,7 +77,7 @@ "conf_leds_layout_cl_righttop": "À droite: 0 - 50% à partir du haut", "conf_leds_layout_cl_top": "Haut", "conf_leds_layout_cl_topleft": "En haut à gauche (coin)", - "conf_leds_layout_cl_topright": "Le coin supérieur droit)", + "conf_leds_layout_cl_topright": "En haut à droite (coin)", "conf_leds_layout_cl_vleddepth": "Profondeur verticale des LED", "conf_leds_layout_frame": "Disposition classique (cadre LED)", "conf_leds_layout_generatedconf": "Configuration LED générée/actuelle", @@ -161,7 +161,7 @@ "dashboard_infobox_label_currenthyp": "Votre version HyperHDR:", "dashboard_infobox_label_disableh": "Désactiver l'instance: $1", "dashboard_infobox_label_enableh": "Activer l'instance: $1", - "dashboard_infobox_label_instance": "Exemple:", + "dashboard_infobox_label_instance": "Instance:", "dashboard_infobox_label_latesthyp": "Dernière version HyperHDR:", "dashboard_infobox_label_platform": "Plate-forme:", "dashboard_infobox_label_ports": "Ports (plat|proto):", @@ -187,11 +187,11 @@ "edt_append_ms": "ms", "edt_append_ns": "ns", "edt_append_percent": "%", - "edt_append_percent_h": "% horaire", - "edt_append_percent_v": "% vert", + "edt_append_percent_h": "% horiz.", + "edt_append_percent_v": "% vertic.", "edt_append_pixel": "Pixels", "edt_append_s": "s", - "edt_append_sdegree": "s/diplôme", + "edt_append_sdegree": "s/degré", "edt_conf_bb_blurRemoveCnt_title": "Pixel de flou", "edt_conf_bb_blurRemoveCnt_expl": "Nombre de pixels supprimés de la bordure détectée pour éliminer le flou.", "edt_conf_bb_borderFrameCnt_title": "Cadres de bordure", @@ -231,9 +231,9 @@ "edt_conf_color_leds_expl": "Affectez ce réglage à toutes les LED (*) ou à quelques-unes seulement (0-24).", "edt_conf_color_magenta_title": "Magenta", "edt_conf_color_magenta_expl": "La valeur magenta calibrée.", - "edt_conf_color_red_title": "rouge", + "edt_conf_color_red_title": "Rouge", "edt_conf_color_red_expl": "La valeur rouge calibrée.", - "edt_conf_color_white_title": "blanche", + "edt_conf_color_white_title": "Blanche", "edt_conf_color_white_expl": "La valeur du blanc calibrée.", "edt_conf_color_yellow_title": "Jaune", "edt_conf_color_yellow_expl": "La valeur jaune calibrée.", @@ -278,7 +278,7 @@ "edt_conf_enum_logverbose": "Verbeux", "edt_conf_enum_logwarn": "Avertissement", "edt_conf_enum_rbg": "RBG", - "edt_conf_enum_rgb": "RVB", + "edt_conf_enum_rgb": "RGB", "edt_conf_enum_right_left": "De droite à gauche", "edt_conf_enum_top_down": "De haut en bas", "edt_conf_enum_transeffect_smooth": "Lisse", @@ -429,7 +429,7 @@ "edt_dev_enum_sub_min_warm_adjust": "Soustraire le blanc chaud", "edt_dev_enum_subtract_minimum": "Soustraire minimum", "edt_dev_enum_white_off": "Blanc éteint", - "edt_dev_general_colorOrder_title": "Ordre des octets RVB", + "edt_dev_general_colorOrder_title": "Ordre des octets RGB", "edt_dev_general_hardwareLedCount_title": "Nombre de voyants du matériel", "edt_dev_general_heading_title": "réglages généraux", "edt_dev_general_name_title": "Nom de la configuration", @@ -746,7 +746,7 @@ "infoDialog_import_confirm_title": "Confirmer l'importation", "infoDialog_import_hyperror_text": "Le fichier de configuration sélectionné \"$1\" ne peut pas être importé. Il n'est pas compatible avec HyperHDR v17 et supérieur!", "infoDialog_import_jsonerror_text": "Le fichier de configuration sélectionné \"$1\" n'est pas un fichier .json ou il est corrompu. Message d'erreur: ($2)", - "infoDialog_wizrgb_text": "Votre ordre d'octets RVB est déjà bien ajusté.", + "infoDialog_wizrgb_text": "Votre ordre d'octets RGB est déjà bien ajusté.", "infoDialog_writeconf_error_text": "L'enregistrement de votre configuration a échoué.", "infoDialog_writeimage_error_text": "Le fichier sélectionné \"$1\" n'est pas un fichier image ou il est corrompu! Veuillez sélectionner un autre fichier image.", "info_404": "La page que vous avez demandée n'est pas disponible !", @@ -806,7 +806,7 @@ "remote_input_sourceactiv_btn": "Source active", "remote_input_status": "Statut/Action", "remote_losthint": "Remarque: toutes les modifications sont perdues après un redémarrage.", - "remote_maptype_intro": "Habituellement, la disposition des LED définit quelle LED couvre une zone d'image spécifique, vous pouvez la modifier ici: $1", + "remote_maptype_intro": "La disposition des LED définit quelle partie de l’image chaque LED utilise ; ici, vous pouvez sélectionner l’algorithme. $1", "remote_maptype_label": "Type de mappage", "remote_maptype_label_multicolor_mean": "Multicolore", "remote_maptype_label_unicolor_mean": "Unicolore", @@ -919,7 +919,7 @@ "wiz_rgb_qgend": "...vert?", "wiz_rgb_qrend": "...rouge?", "wiz_rgb_switchevery": "Changer de couleur tous les ...", - "wiz_rgb_title": "Assistant de commande RVB", + "wiz_rgb_title": "Assistant de commande RGB", "wiz_wizavail": "Assistant disponible", "wiz_yeelight_desc2": "Choisissez maintenant les lampes à ajouter. La position attribue la lampe à une position spécifique sur votre \"photo\". Les lampes désactivées ne seront pas ajoutées. Pour identifier les lampes individuelles, appuyez sur le bouton de droite.", "wiz_yeelight_intro1": "Cet assistant configure HyperHDR pour le système Yeelight. Les fonctionnalités sont la détection automatique des Yeelighs, réglant chaque lumière sur une position spécifique sur votre image ou la désactivent et ajustent automatiquement les paramètres HyperHDR! En bref: il vous suffit de quelques clics et le tour est joué !", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Appareil de capture du son", "edt_conf_sound_device_expl": "Dispositif de capture de son système pour les plugins utilisant la visualisation musicale", "available_sound_devices": "Dispositifs de capture sonore disponibles", - "edt_conf_smooth_antiFlickeringTreshold_title": "Valeur seuil anti-scintillement", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Les lecteurs vidéo ou le contenu vidéo compressé introduisent un tramage aléatoire lors de la lecture de films. Bien que les changements de valeur RVB puissent être minimes, ils peuvent provoquer un effet de scintillement sur votre système ambilight sur des scènes sombres. Par exemple, changer l'une des valeurs RVB de 1 à 3 à partir du tramage a un petit effet visuel sur les scènes lumineuses, mais en basse lumière, c'est assez dramatique. Vous pouvez activer le système anti-scintillement pour le mode faible luminosité et définir un seuil pour appliquer un filtre afin d'éviter cette situation pour RVB en dessous de cette valeur. Les leds lumineuses avec RVB au-dessus de ce seuil ne sont pas touchées par le filtre. Fonctionne mieux avec un rétroéclairage minimal coloré dans l'onglet de traitement.
Si vous rencontrez un scintillement sur un film statique/en pause, votre problème est probablement de nature électrique et cette option n'aidera pas. (0 = l'option est désactivée, sinon la valeur proposée a 32 ans)", - "edt_conf_smooth_antiFlickeringValue_title": "Pas minimal anti-scintillement", - "edt_conf_smooth_antiFlickeringValue_expl": "Changement minimal requis du canal de couleur (rappel: la plage RVB complète est de 0 à 255 chacun) qui doit être atteint pour affecter la source LED. La cible noire RVB (0,0,0) omet cela pour préserver l'extinction des LED si le rétroéclairage est désactivé", "main_ledsim_btn_screenshot": "Capture d'écran", "edt_conf_enum_linear_alternative": "Linéaire alternatif (plus rapide)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Délai d'attente anti-scintillement", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Permet de changer une couleur de led RVB, après un temps personnalisé en millisecondes, même si le pas est en dessous du minimum (0 = désactivé, sinon la valeur proposée est d'au moins 500 ce qui donne 0.5 secondes)", "dashboard_current_video_device": "Appareil vidéo", "dashboard_current_video_mode": "Mode vidéo", "general_comp_HDR": "HDR (mondial)", @@ -1035,7 +1029,7 @@ "edt_conf_stream_sleep_time_title": "Temps de sommeil", "edt_conf_stream_sleep_time_expl": "Temps de sommeil si le signal est perdu pendant cette période", "edt_conf_stream_error_tolerance_title": "Tolérance au bruit", - "edt_conf_stream_error_tolerance_expl": "Déviation des valeurs RVB (liées au bruit vidéo)", + "edt_conf_stream_error_tolerance_expl": "Déviation des valeurs RGB (liées au bruit vidéo)", "edt_conf_stream_model_tolerance_title": "Tolérance cognitive", "edt_conf_stream_model_tolerance_expl": "Déviation du modèle cognitif (pourcentage de points de test qui doivent passer le test pour détecter le modèle)", "edt_conf_stream_automatic_signalDetection_title": "Détection automatique du signal", @@ -1061,11 +1055,11 @@ "main_menu_advanced_token": "Avancée", "about_ui": "Principaux composants de l'interface utilisateur", "about_system_info": "Information système", - "lut_generator_intro": "La table LUT d'HyperHDR est utilisée pour le mappage des tonalités HDR vers SDR lorsqu'elle est activée dans les paramètres du grabber. AUSSI, LA TABLE LUT EST UTILISÉE POUR LA CORRECTION DES CANAUX RVB GAMMA ET LE SEUIL MINIMAL POUR TOUS LES DECODEURS YUV (YUV, NV12, I420) À RVB STREAM MÊME SANS L'OPTION DE MAPPAGE DE TONALITÉ ACTIVÉE. Il est recommandé de capturer une capture d'écran de votre aperçu de la capture dans le navigateur (désactivez d'abord le mappage des tons hdr) pour tester les paramètres de cet échantillon.
Après avoir fini de créer une nouvelle table LUT, veuillez télécharger le nouveau 'lut_lin_tables.3d' sur votre dossier de configuration.
Votre dossier de configuration typique dans lequel télécharger ce fichier est (consultez la page 'Journaux' pour confirmer):
Rpi→/home/pi/.hyperhdr
Windows→c:/Users/NAME /.hyperhdr", + "lut_generator_intro": "La table LUT d'HyperHDR est utilisée pour le mappage des tonalités HDR vers SDR lorsqu'elle est activée dans les paramètres du grabber. AUSSI, LA TABLE LUT EST UTILISÉE POUR LA CORRECTION DES CANAUX RGB GAMMA ET LE SEUIL MINIMAL POUR TOUS LES DECODEURS YUV (YUV, NV12, I420) À RGB STREAM MÊME SANS L'OPTION DE MAPPAGE DE TONALITÉ ACTIVÉE. Il est recommandé de capturer une capture d'écran de votre aperçu de la capture dans le navigateur (désactivez d'abord le mappage des tons hdr) pour tester les paramètres de cet échantillon.
Après avoir fini de créer une nouvelle table LUT, veuillez télécharger le nouveau 'lut_lin_tables.3d' sur votre dossier de configuration.
Votre dossier de configuration typique dans lequel télécharger ce fichier est (consultez la page 'Journaux' pour confirmer):
Rpi→/home/pi/.hyperhdr
Windows→c:/Users/NAME /.hyperhdr", "lut_generator_header": "Générateur de table SDR&HDR LUT", - "lut_generator_main1": "Seuil minimal pour chaque couleur de RVB (0-peut être supérieur à 255 avant écrêtage). Une valeur inférieure ou égale au paramètre est considérée comme 0. Utile pour le bruit dans les scènes sombres et laisse entrer la luminosité minimale du traitement de l'image. Fonctionne pour l'option de mappage de tonalité HDR activée.", + "lut_generator_main1": "Seuil minimal pour chaque couleur de RGB (0-peut être supérieur à 255 avant écrêtage). Une valeur inférieure ou égale au paramètre est considérée comme 0. Utile pour le bruit dans les scènes sombres et laisse entrer la luminosité minimale du traitement de l'image. Fonctionne pour l'option de mappage de tonalité HDR activée.", "lut_generator_main2": "Correction gamma pour chaque canal. Utile si vous rencontrez par exemple: trop de vert ou votre image est trop sombre et votre pince ne permet pas de contrôler la luminosité. Fonctionne pour l'option de mappage de tonalité HDR activée.", - "lut_generator_main3": "Seuil minimal pour chaque couleur de RVB (0-255). Une valeur inférieure ou égale au paramètre est considérée comme 0. Utile pour le bruit dans les scènes sombres et laisse entrer la luminosité minimale du traitement de l'image. Fonctionne pour les codecs YUV (YUV/NV12/I420) sans l'option de mappage de tonalité HDR activée.", + "lut_generator_main3": "Seuil minimal pour chaque couleur de RGB (0-255). Une valeur inférieure ou égale au paramètre est considérée comme 0. Utile pour le bruit dans les scènes sombres et laisse entrer la luminosité minimale du traitement de l'image. Fonctionne pour les codecs YUV (YUV/NV12/I420) sans l'option de mappage de tonalité HDR activée.", "lut_generator_main4": "Correction gamma pour chaque canal. Utile si vous rencontrez par exemple: trop de vert ou votre image est trop sombre et votre pince ne permet pas de contrôler la luminosité. Fonctionne pour les codecs YUV (YUV/NV12/I420) sans l'option de mappage de tonalité HDR activée.", "lut_generator_opt1_r": "Min. seuil rouge", "lut_generator_opt1_g": "Min. vert de seuil", @@ -1132,16 +1126,16 @@ "edt_conf_fbs_hdrToneMappingMode_title": "Zone pour l'effet du mode LUT", "edt_conf_fbs_hdrToneMappingMode_expl": "Mode plein écran ou bordure plus rapide", "general_comp_RAWUDPSERVER": "Récepteur brut UDP", - "edt_udp_raw_server": "Un serveur léger pour la synchronisation à distance des instances HyperHDR à l'aide des couleurs UDP et RVB brutes des LED. Peut également être contrôlé depuis d'autres applications (similaire au serveur Boblight) de manière très simple. Pour la synchronisation HyperHDR, utilisez la source lumineuse 'udpraw' dans l'expéditeur.
Important: les deux instances doivent avoir le même nombre de LED (maximum 490) et la même géométrie pour que cela fonctionne. Le lissage ne doit être activé que sur une seule instance, pas sur les deux!", + "edt_udp_raw_server": "Un serveur léger pour la synchronisation à distance des instances HyperHDR à l'aide des couleurs UDP et RGB brutes des LED. Peut également être contrôlé depuis d'autres applications (similaire au serveur Boblight) de manière très simple. Pour la synchronisation HyperHDR, utilisez la source lumineuse 'udpraw' dans l'expéditeur.
Important: les deux instances doivent avoir le même nombre de LED (maximum 490) et la même géométrie pour que cela fonctionne. Le lissage ne doit être activé que sur une seule instance, pas sur les deux!", "main_menu_grabber_calibration_token": "Étalonnage LUT", "grabber_calibration_force": "Forcer la détection automatique:", "edt_dev_max_retry": "Nombre maximal de tentatives", - "edt_rgbw_calibration_enable": "Étalonnage du canal blanc (RVBW uniquement)", + "edt_rgbw_calibration_enable": "Étalonnage du canal blanc (RGBW uniquement)", "edt_rgbw_calibration_limit": "Limite du canal blanc", "edt_rgbw_calibration_red": "Aspect du canal rouge/blanc", "edt_rgbw_calibration_green": "Aspect du canal vert/blanc", "edt_rgbw_calibration_blue": "Aspect du canal bleu/blanc", - "calibration_channel_info": "Vous avez besoin de HyperSerialEsp8266/HyperSerialESP32/HyperSPI version 6 pour que cela fonctionne. Lorsque cette option est désactivée, les paramètres d'étalonnage du micrologiciel interne sont utilisés.

La LED normalement blanche des bandes LED RGBW peut être plus puissante que la combinaison de couleurs obtenue en mélangeant RVB. Grâce à la limite, il est possible d'équilibrer la puissance du canal.

Le canal blanc 'Neutral RGBW' n'est pas proche de la couleur obtenue en mélangeant des LED RGB. C'est un peu jaune donc vous devrez peut-être baisser l'aspect bleu/blanc pour rendre le canal bleu plus fort. 'Cold RGBW' est généralement mieux équilibré.

Astuce: Affichez une couleur blanche statique dans l'onglet de la télécommande. Réglez ensuite la limite du canal blanc sur 100% et l'aspect rouge/vert/bleu sur 255 pour activer le canal blanc à la portée maximale. Alternativement, vous pouvez régler l'aspect rouge/vert/bleu sur 0 pour désactiver le canal blanc et émuler la couleur blanche à l'aide de RVB pour voir la différence.", + "calibration_channel_info": "Vous avez besoin de HyperSerialEsp8266/HyperSerialESP32/HyperSPI version 6 pour que cela fonctionne. Lorsque cette option est désactivée, les paramètres d'étalonnage du micrologiciel interne sont utilisés.

La LED normalement blanche des bandes LED RGBW peut être plus puissante que la combinaison de couleurs obtenue en mélangeant RGB. Grâce à la limite, il est possible d'équilibrer la puissance du canal.

Le canal blanc 'Neutral RGBW' n'est pas proche de la couleur obtenue en mélangeant des LED RGB. C'est un peu jaune donc vous devrez peut-être baisser l'aspect bleu/blanc pour rendre le canal bleu plus fort. 'Cold RGBW' est généralement mieux équilibré.

Astuce: Affichez une couleur blanche statique dans l'onglet de la télécommande. Réglez ensuite la limite du canal blanc sur 100% et l'aspect rouge/vert/bleu sur 255 pour activer le canal blanc à la portée maximale. Alternativement, vous pouvez régler l'aspect rouge/vert/bleu sur 0 pour désactiver le canal blanc et émuler la couleur blanche à l'aide de RGB pour voir la différence.", "conf_grabber_pipewire_intro": "Pour utiliser le système d'acquisition 'pipewire/portal', HyperHDR doit être exécuté en tant qu'application, le lancement en tant que service/démon échouera", "edt_conf_fbs_tonemapping_expl": "S'il est activé, HyperHDR appliquera la correction LUT pour le flux entrant. Fonctionne également pour Protocol Buffers Server. Assurez-vous d'avoir la bonne table LUT. Le fichier LUT 3D par défaut pour HDR10: 'lut_lin_tables.3d' (le nom de fichier 'flat_lut_lin_tables.3d' est également accepté) est déjà inclus. Vous pouvez en générer un et prévisualiser l'effet en utilisant le lien dans le \"menu Avancé\".
Votre dossier de configuration caché typique pour télécharger ce fichier est (vérifiez la page \"Journaux\" pour confirmer):
Rpi→/home/pi/.hyperhdr
Windows→c:/Utilisateurs/NOM/.hyperhdr", "conf_grabber_framebuffer_intro": "Capture d'écran Linux FrameBuffer", @@ -1222,8 +1216,8 @@ "edt_conf_monitor_nits_title": "Correction de la luminosité HDR", "edt_conf_monitor_nits_expl": "Luminosité cible SDR utilisée pour la conversion HDR en SDR. Si 0, il désactive la conversion matérielle des couleurs tout en maintenant une mise à l'échelle accélérée.", "edt_append_nits": "nits", - "edt_conf_gen_disableOnLocked_title": "Désactiver lorsqu'il est verrouillé", - "edt_conf_gen_disableOnLocked_expl": "Désactiver le traitement lorsque l'utilisateur a verrouillé le système.", + "edt_conf_gen_disableOnLocked_title": "Désactiver lorsque le système est verrouillé ou que l’écran est éteint", + "edt_conf_gen_disableOnLocked_expl": "Interrompt le traitement du grabber logiciel lors du verrouillage du système ou de l’extinction de l’écran.", "edt_conf_gen_disableLedsStartup_title": "Éteignez les LED au démarrage", "edt_conf_gen_disableLedsStartup_expl": "Désactivez les LED et tous les composants au démarrage, vous devez les réactiver manuellement sur la page principale ou via l'API JSON (composant COMP_ALL).", "edt_conf_sound_device_smoothing_title": "Activer le lissage", @@ -1231,21 +1225,21 @@ "option_calibration_intro": "Veuillez sélectionner le type d'étalonnage", "option_calibration_video": "Étalonnage à l'aide d'une vidéo de test lue par votre lecteur vidéo préféré.
Nous étalonnons la LUT en tenant compte du grabber, du lecteur et de votre téléviseur.", "option_calibration_classic": "Étalonnage à l'aide de Windows avec le mode HDR activé et d'un navigateur Web.
Nous étalonnons la LUT en tenant compte du grabber et de votre téléviseur.", - "video_calibration_overview": "1 Vous devez définir le format vidéo de votre grabber sur MJPEG/YUV/NV12/P010. Les autres formats ne sont pas pris en charge.

2 Si vous étalonnez à l'aide de Flatbuffers, vous devez activer le mappage de tonalités dans ses paramètres. Seul le format vidéo NV12 est pris en charge.

3 Vous pouvez télécharger les fichiers de test ici: lien. Dans votre lecteur, lancez la lecture du fichier de test. Vous devriez le voir dans l'aperçu vidéo HyperHDR. L'écran de test doit occuper tout l'écran et aucun élément étranger, tel que le menu du lecteur, ne doit être visible.

4 Pour l'étalonnage, vous devez choisir un fichier avec 'hdr' dans le nom, sauf si votre système ou votre lecteur utilise automatiquement le mappage de tonalité SDR vers HDR ou si vous prévoyez d'étalonner le signal SDR. Dans ce cas, pour vous adapter à un tel scénario, choisissez un fichier avec 'sdr' dans le nom.

5 Le format YUV420 à portée limitée offre la plus grande compatibilité avec une qualité moyenne à très bonne et est le plus populaire. Le format YUV444 offre la meilleure qualité, mais il est rare de trouver des matériaux encodés sous cette forme.

6 Si vous effectuez l'étalonnage à l'aide de Windows 11 (en utilisant un navigateur Web ou un lecteur vidéo comme source vidéo), désactivez des fonctionnalités telles que 'Veilleuse', 'Gestion automatique des couleurs pour les applications' et 'Auto-HDR'. Ne modifiez pas la balance des couleurs dans le pilote graphique. La sortie GFX doit prendre en charge par exemple RVB 10 ou 12 bits dans toute la gamme PC.

7 Les calculs sont très intensifs et mettent à rude épreuve votre équipement! Vous pouvez désactiver la correction des couleurs LCH pour réduire un peu la charge", + "video_calibration_overview": "1 Vous devez définir le format vidéo de votre grabber sur MJPEG/YUV/NV12/P010. Les autres formats ne sont pas pris en charge.

2 Si vous étalonnez à l'aide de Flatbuffers, vous devez activer le mappage de tonalités dans ses paramètres. Seul le format vidéo NV12 est pris en charge.

3 Vous pouvez télécharger les fichiers de test ici: lien. Dans votre lecteur, lancez la lecture du fichier de test. Vous devriez le voir dans l'aperçu vidéo HyperHDR. L'écran de test doit occuper tout l'écran et aucun élément étranger, tel que le menu du lecteur, ne doit être visible.

4 Pour l'étalonnage, vous devez choisir un fichier avec 'hdr' dans le nom, sauf si votre système ou votre lecteur utilise automatiquement le mappage de tonalité SDR vers HDR ou si vous prévoyez d'étalonner le signal SDR. Dans ce cas, pour vous adapter à un tel scénario, choisissez un fichier avec 'sdr' dans le nom.

5 Le format YUV420 à portée limitée offre la plus grande compatibilité avec une qualité moyenne à très bonne et est le plus populaire. Le format YUV444 offre la meilleure qualité, mais il est rare de trouver des matériaux encodés sous cette forme.

6 Si vous effectuez l'étalonnage à l'aide de Windows 11 (en utilisant un navigateur Web ou un lecteur vidéo comme source vidéo), désactivez des fonctionnalités telles que 'Veilleuse', 'Gestion automatique des couleurs pour les applications' et 'Auto-HDR'. Ne modifiez pas la balance des couleurs dans le pilote graphique. La sortie GFX doit prendre en charge par exemple RGB 10 ou 12 bits dans toute la gamme PC.

7 Les calculs sont très intensifs et mettent à rude épreuve votre équipement! Vous pouvez désactiver la correction des couleurs LCH pour réduire un peu la charge", "chk_calibration_debug": "Débogage", - "flatbuffers_nv12_quarter_of_frame_title": "Quart de trame pour NV12", + "flatbuffers_nv12_quarter_of_frame_title": "Réduire la taille d'image NV12 à 25%", "flatbuffers_nv12_quarter_of_frame_expl": "Le codec NV12 contient quatre fois plus d'informations sur la luminosité que sur la couleur. Cette option vous permet de réduire la charge du processeur en réduisant la hauteur et la largeur de la trame vidéo de 2 sans perdre d'informations de couleur.", "chk_lchCorrection": "Correction des couleurs LCH", - "grabber_calibration_expl": "Cet outil vous permet de créer une nouvelle LUT HDR calibrée pour votre grabber (ou source flatbuffers externe) aussi proche que possible des couleurs d'entrée réelles.
Vous avez besoin d'une source vidéo HDR10 qui peut afficher cette page Web, par exemple: Windows 10 avec HDR activé dans les propriétés du pilote graphique.
L'écran peut scintiller pendant l'étalonnage. Le processus prend généralement quelques minutes sur un PC Windows Intel 7 (en fonction des ressources du processeur hôte et de la fréquence d'images de capture vidéo).
Les calculs sont très intensifs et mettent à rude épreuve votre équipement Vous pouvez désactiver la correction des couleurs LCH pour réduire un peu la charge
Vous pouvez surveiller la progression dans les journaux HyperHDR à l'aide du navigateur d'un autre appareil.


1 Si tout est correctement connecté, cette page doit s'afficher sur l'écran du téléviseur (en tant que contenu HDR) et un aperçu en direct dans HyperHDR (capturé par le grabber).
2 La résolution de capture minimale absolue est de 1280x720 (nous vérifierons cela). La résolution recommandée est 1920x1080 YUV/NV12. Français L'aspect 1920/1080 doit être préservé.
3 Vous devez désactiver le 'Réduire la taille d'image à 25%' dans les propriétés de votre carte d'acquisition s'il est activé.
4 Vous devez définir le format vidéo de la carte d'acquisition sur MJPEG/YUV/NV12/P010.
5 Avant d'exécuter le processus, veuillez mettre votre navigateur Web en mode plein écran (touche F11, nous vérifierons cela).
6 Si vous effectuez l'étalonnage à l'aide de Windows 11, désactivez des fonctionnalités telles que 'Veilleuse', 'Gestion automatique des couleurs pour les applications' et 'Auto-HDR'. Ne modifiez pas la balance des couleurs dans le pilote graphique. La sortie GFX doit prendre en charge par exemple 10 ou 12 bits RVB dans toute la gamme PC.

Une fois l'étalonnage terminé, votre nouveau fichier de table LUT (lut_lin_tables.3d) sera créé dans le répertoire personnel HyperHDR de l'utilisateur et sera immédiatement prêt à être utilisé lorsque vous activez simplement le mappage de tons HDR. Veuillez vérifier les journaux HyperHDR pour plus de détails.", + "grabber_calibration_expl": "Cet outil vous permet de créer une nouvelle LUT HDR calibrée pour votre grabber (ou source flatbuffers externe) aussi proche que possible des couleurs d'entrée réelles.
Vous avez besoin d'une source vidéo HDR10 qui peut afficher cette page Web, par exemple: Windows 10 avec HDR activé dans les propriétés du pilote graphique.
L'écran peut scintiller pendant l'étalonnage. Le processus prend généralement quelques minutes sur un PC Windows Intel 7 (en fonction des ressources du processeur hôte et de la fréquence d'images de capture vidéo).
Les calculs sont très intensifs et mettent à rude épreuve votre équipement Vous pouvez désactiver la correction des couleurs LCH pour réduire un peu la charge
Vous pouvez surveiller la progression dans les journaux HyperHDR à l'aide du navigateur d'un autre appareil.


1 Si tout est correctement connecté, cette page doit s'afficher sur l'écran du téléviseur (en tant que contenu HDR) et un aperçu en direct dans HyperHDR (capturé par le grabber).
2 La résolution de capture minimale absolue est de 1280x720 (nous vérifierons cela). La résolution recommandée est 1920x1080 YUV/NV12. Français L'aspect 1920/1080 doit être préservé.
3 Vous devez désactiver le 'Réduire la taille d'image à 25%' dans les propriétés de votre carte d'acquisition s'il est activé.
4 Vous devez définir le format vidéo de la carte d'acquisition sur MJPEG/YUV/NV12/P010.
5 Avant d'exécuter le processus, veuillez mettre votre navigateur Web en mode plein écran (touche F11, nous vérifierons cela).
6 Si vous effectuez l'étalonnage à l'aide de Windows 11, désactivez des fonctionnalités telles que 'Veilleuse', 'Gestion automatique des couleurs pour les applications' et 'Auto-HDR'. Ne modifiez pas la balance des couleurs dans le pilote graphique. La sortie GFX doit prendre en charge par exemple 10 ou 12 bits RGB dans toute la gamme PC.

Une fois l'étalonnage terminé, votre nouveau fichier de table LUT (lut_lin_tables.3d) sera créé dans le répertoire personnel HyperHDR de l'utilisateur et sera immédiatement prêt à être utilisé lorsque vous activez simplement le mappage de tons HDR. Veuillez vérifier les journaux HyperHDR pour plus de détails.", "edt_automatic_tone_mapping_title": "Mappage automatique des tons", - "edt_automatic_tone_mapping_enable_explain": "Le contrôle du mappage automatique des tons n'est disponible que pour les formats vidéo YUV/NV12/P010' avec le mode 'Quarter of frame' activé. Veuillez les configurer dans les paramètres du grabber USB.
Le composant activera automatiquement le mappage des tons si le signal ne dépasse pas les niveaux de seuil configurés pendant une certaine période de temps, et le désactivera immédiatement après les avoir dépassés.
Vous pouvez ensuite vérifier quelle est la valeur qui a dépassé l'un des seuils, ce qui a effectivement provoqué la désactivation du tone mapping dans les journaux HyperHDR. Et éventuellement ajuster la configuration si elle génère de faux événements de désactivation du tone mapping (seuil trop bas) ou génère une activation inutile du tone mapping dans les scènes SDR sombres (seuil trop élevé).", + "edt_automatic_tone_mapping_enable_explain": "Le contrôle du mappage automatique des tons n'est disponible que pour les formats vidéo YUV/NV12/P010' avec le mode 'Réduire la taille d'image à 25%' activé. Veuillez les configurer dans les paramètres du grabber USB.
Le composant activera automatiquement le mappage des tons si le signal ne dépasse pas les niveaux de seuil configurés pendant une certaine période de temps, et le désactivera immédiatement après les avoir dépassés.
Vous pouvez ensuite vérifier quelle est la valeur qui a dépassé l'un des seuils, ce qui a effectivement provoqué la désactivation du tone mapping dans les journaux HyperHDR. Et éventuellement ajuster la configuration si elle génère de faux événements de désactivation du tone mapping (seuil trop bas) ou génère une activation inutile du tone mapping dans les scènes SDR sombres (seuil trop élevé).", "edt_automatic_tone_mapping_y_threshold_title": "Seuil de luminosité (Y)", "edt_automatic_tone_mapping_y_threshold_expl": "Le niveau de luminosité qui sépare le matériel HDR brut foncé du signal SDR.", "edt_automatic_tone_mapping_u_threshold_title": "Seuil de chrominance bleue (U)", "edt_automatic_tone_mapping_u_threshold_expl": "Niveau de chrominance bleue qui sépare le matériel HDR brut pâle du signal SDR.", "edt_automatic_tone_mapping_v_threshold_title": "Seuil de chrominance rouge (V)", "edt_automatic_tone_mapping_v_threshold_expl": "Niveau de chrominance rouge qui sépare le matériel HDR brut pâle du signal SDR.", - "edt_automatic_tone_mapping_time_title": "Il est temps d'activer le mappage des tons", + "edt_automatic_tone_mapping_time_title": "Temps d'activation du mappage des tons", "edt_automatic_tone_mapping_time_expl": "Il est temps d'activer le mappage des tons si le signal ne dépasse pas les niveaux de seuil configurés.", "edt_automatic_tone_mapping_disable_time_title": "Il est temps de désactiver le tone mapping", "edt_automatic_tone_mapping_disable_time_expl": "Dans un monde idéal, cette valeur devrait être nulle, car le tone mapping devrait être désactivé immédiatement après avoir dépassé l'un des seuils. Mais cela arrive, par exemple: lors du démarrage ou du changement de résolution, le grabber peut générer des trames indésirables, ce qui peut désactiver le tone mapping inutilement.", @@ -1274,14 +1268,14 @@ "edt_conf_enum_warm": "Chaud", "edt_conf_enum_interpolator_Stepper_title": "Interpolateur linéaire", "edt_conf_enum_interpolator_Stepper_expl": "L'interpolateur linéaire est une adaptation d'un algorithme hérité des versions précédentes d'HyperHDR, réécrit pour utiliser l'arithmétique à virgule flottante pour une plus grande précision. Il fonctionne en interpolant linéairement la couleur actuelle vers une couleur cible, garantissant une transition complète sur une durée définie, quelle que soit la fréquence d'images. Sa principale caractéristique est la possibilité de recibler en douceur en cours d'animation, initiant une nouvelle transition complète de l'état actuel vers le nouvel objectif.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolateur RVB infini", - "edt_conf_enum_interpolator_RgbInterpolator_expl": "Cet algorithme anime les couleurs RVB de manière fluide sur une durée définie, offrant deux modes de transition distincts. Le premier est une interpolation linéaire directe pour un chemin rectiligne entre les couleurs, tandis que le second est un mode lissé où la couleur actuelle 'suit' gracieusement la cible pour créer un effet d'entrée/sortie progressive. Une de ses principales caractéristiques est sa capacité à redimensionner intelligemment la durée d'une animation lorsqu'elle est interrompue, garantissant une vitesse de changement perceptiblement constante.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolateur infini YUV", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolateur RGB Infinite", + "edt_conf_enum_interpolator_RgbInterpolator_expl": "Cet algorithme anime les couleurs RGB de manière fluide sur une durée définie, offrant deux modes de transition distincts. Le premier est une interpolation linéaire directe pour un chemin rectiligne entre les couleurs, tandis que le second est un mode lissé où la couleur actuelle 'suit' gracieusement la cible pour créer un effet d'entrée/sortie progressive. Une de ses principales caractéristiques est sa capacité à redimensionner intelligemment la durée d'une animation lorsqu'elle est interrompue, garantissant une vitesse de changement perceptiblement constante.", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolateur YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Cet algorithme interpole les couleurs en douceur en opérant dans l'espace colorimétrique YUV pour des transitions plus uniformes sur le plan perceptuel. Sa principale caractéristique est de limiter le taux de variation de luminance à chaque étape, évitant ainsi les éclairs de luminosité soudains et discordants. Cela garantit un effet visuel agréable, même si l'animation est prolongée au-delà de sa durée initiale pour maintenir cette fluidité.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolateur infini à physique hybride (YUV)", - "edt_conf_enum_interpolator_HybridInterpolator_expl": "Cet algorithme effectue des transitions fluides entre les couleurs grâce à un modèle physique hybride. Un 'rythme' linéaire définit le chemin direct et le timing vers la couleur cible, tandis que la couleur de sortie réelle suit ce rythme comme un objet attaché à un ressort amorti. Cette approche en deux parties crée des animations fluides et naturelles, avec une inertie et un dépassement personnalisables, tout en opérant dans l'espace colorimétrique YUV, perceptuellement uniforme.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolateur infini à physique hybride (RVB)", - "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Cet algorithme assure une transition fluide entre les couleurs grâce à un modèle physique hybride. Un 'rythme' linéaire définit la trajectoire et le timing directs vers la couleur cible, tandis que la couleur de sortie suit ce rythme comme un objet attaché à un ressort amorti. Cette approche en deux étapes permet de créer des animations fluides et naturelles, avec une inertie et un dépassement personnalisables, tout en opérant dans l'espace colorimétrique RVB.", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolateur Infinite : physique hybride avec inertie (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_expl": "Cet algorithme effectue une transition fluide entre les couleurs en utilisant un modèle physique hybride. Une trajectoire linéaire et un temps d’arrivée vers la couleur cible sont d’abord définis, puis la couleur de sortie suit cette trajectoire comme un objet attaché à un ressort amorti. Cette approche en deux étapes produit des animations fluides et naturelles avec inertie et dépassement configurables, tout en opérant dans l’espace colorimétrique YUV perceptuellement uniforme.", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolateur Infinite : physique hybride avec inertie (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Cet algorithme effectue une transition fluide entre les couleurs en utilisant un modèle physique hybride. Une trajectoire linéaire et un temps d’arrivée vers la couleur cible sont d’abord définis, puis la couleur de sortie suit cette trajectoire comme un objet attaché à un ressort amorti. Cette approche en deux étapes produit des animations fluides et naturelles avec inertie et dépassement configurables, tout en opérant dans l’espace colorimétrique RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Facteur de lissage", "edt_conf_enum_interpolator_smoothingFactor_expl": "Ce paramètre détermine l'ambiance de l'animation et contrôle la transition entre les couleurs. Il accepte une valeur comprise entre 0.0 et 1.0, où 0.0 entraîne une variation directe et linéaire. Des valeurs plus élevées introduisent davantage de lissage, créant un mouvement fluide de 'poursuite' lorsque la couleur actuelle est légèrement en retard par rapport à la position idéale.", "edt_conf_enum_interpolator_stiffness_title": "Rigidité", @@ -1294,19 +1288,20 @@ "edt_conf_color_backlightThreshold_expl": "Niveau de luminosité minimal (échelle 0-1.0). Chaque pas de 0.0039(2) correspond à 1 sur l'échelle 0-255. Désactivé pendant les effets, les couleurs et lorsque l'état est \"désactivé\".", "edt_conf_color_channelAdjustment_header_title": "Moteur de couleurs infini", "edt_conf_color_channelAdjustment_header_expl": "Créez des profils de couleurs pouvant être attribués à un composant spécifique. Ajustez la couleur, le gamma, la luminance, la saturation, etc. Calculs de haute précision (flottants) utilisés pour le traitement des couleurs.", - "edt_conf_color_classic_config_title": "Calibrage RVB", + "edt_conf_color_classic_config_title": "Calibrage RGB", "edt_conf_color_classic_config_expl": "Calibrage utilisant les trois couleurs primaires (rouge, vert, bleu). Suffisant dans la plupart des cas.", "edt_conf_color_gamma_title": "Gamme utilisateur", "edt_conf_color_gamma_expl": "Gamma supplémentaire pour chaque composante de couleur. La neutralité totale est de 1.0 (désactivation du gamma utilisateur), au-dessus de 1.0, la valeur de la couleur diminue et en dessous, elle l'augmente. Ne confondez pas cela avec, par exemple, la correction gamma sRGB: les couleurs de sortie sont déjà dans un espace non linéaire même sans ce paramètre.", "edt_conf_processing_scaleOutput_title": "Mise à l'échelle des couleurs", - "edt_conf_processing_scaleOutput_expl": "Multiplie les composantes de couleur RVB par un facteur donné dans l'espace RVB linéaire.", + "edt_conf_processing_scaleOutput_expl": "Multiplie les composantes de couleur RGB par un facteur donné dans l'espace RGB linéaire.", "edt_conf_processing_powerLimit_title": "Limitation de la puissance de sortie", "edt_conf_processing_powerLimit_expl": "Cette fonctionnalité vérifie si la consommation totale d'énergie pour la scène actuelle est dépassée. Si tel est le cas, elle réduit automatiquement la luminosité et la couleur de chaque LED. Veuillez noter que cela ne remplace pas une alimentation suffisamment puissante. Cette fonction est uniquement conçue pour limiter la luminosité excessive et ne protège pas votre équipement des dommages causés par une alimentation sous-dimensionnée. Nous ne garantissons pas que cette fonctionnalité se traduira directement par une limitation de la puissance de la configuration LED à une valeur spécifique.", - "edt_conf_smoothing_testMode_expl": "Changements de couleur soudains et cycliques pour tester les algorithmes de lissage, sortie vers la console (sous Windows, exécutez HyperHDR avec le paramètre -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolateur exponentiel infini", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolateur exponentiel Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "L'implémentation exponentielle classique du lissage actualise les couleurs des LED en fonction d'une cible, réagissant rapidement aux différences importantes et ralentissant à mesure qu'elles s'approchent de la cible, produisant ainsi des transitions d'éclairage ambiant fluides et naturelles.", "edt_dev_spec_macAddress_title": "Adresse MAC", "wiz_lifx_error": "Impossible de trouver les périphériques Lifx. Consultez les journaux HyperHDR.", "wiz_lifx_title": "Assistant d'éclairage LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Convertir en RGB linéaire" + "edt_dev_spec_convertToLinearRgb_title": "Convertir en RGB linéaire", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtre anti‑scintillement", + "edt_conf_smooth_antiFlickeringFilter_expl": "Active un filtre d'Infinite Color Engine qui réduit le scintillement subtil des LED causé par la quantification des couleurs en RGB 24 bits. Les contrôleurs prenant en charge des formats de couleur étendus (deep color), tels que Philips Hue (en mode Entertainment) ou les appareils LIFX, n'ont pas besoin de ce filtre." } diff --git a/www/i18n/it.json b/www/i18n/it.json index 7d7e0bf35..959642c84 100644 --- a/www/i18n/it.json +++ b/www/i18n/it.json @@ -10,11 +10,11 @@ "InfoDialog_lang_title": "Impostazione della lingua", "InfoDialog_nowrite_foottext": "La WebUI verrà sbloccata automaticamente dopo aver risolto il problema!", "InfoDialog_nowrite_text": "HyperHDR non può scrivere nel file di configurazione attualmente caricato. Si prega di riparare i permessi del file per procedere.", - "InfoDialog_nowrite_title": "errore di autorizzazione alla scrittura!", + "InfoDialog_nowrite_title": "Errore di autorizzazione alla scrittura!", "about_3rd_party_licenses": "Licenze di terze parti", "about_3rd_party_licenses_error": "Abbiamo avuto problemi a raccogliere informazioni sulle licenze di terze parti dal Web.
Segui questo link alla risorsa GitHub.", - "about_build": "Costruire", - "about_builddate": "Data di costruzione", + "about_build": "Sorgente build", + "about_builddate": "Data di compilazione", "about_contribute": "Sviluppa ulteriormente HyperHDR con noi!", "about_credits": "Crediti a tutti questi sviluppatori!", "about_resources": "Librerie da $1", @@ -22,19 +22,19 @@ "about_version": "Versione", "conf_colors_blackborder_intro": "Salta le barre nere ovunque si trovino. Ogni modalità utilizza un altro algoritmo di rilevamento che è sintonizzato per situazioni speciali. Alza la soglia se non funziona per te.", "conf_colors_color_intro": "Crea uno o più profili di calibrazione, regola ogni colore, luminosità, linearizzazione e altro.", - "conf_colors_smoothing_intro": "L'arrotondamento appiattisce i cambiamenti di colore/luminosità per ridurre fastidiose distrazioni. L'impostazione di una frequenza di aggiornamento superiore alle capacità del driver della striscia LED può causare ritardi e colli di bottiglia nell'elaborazione.", + "conf_colors_smoothing_intro": "Il livellamento appiattisce i cambiamenti di colore/luminosità per ridurre le fastidiose distrazioni. L'impostazione di una frequenza di aggiornamento superiore alle capacità del driver della striscia LED può causare ritardi e colli di bottiglia nell'elaborazione.", "conf_effect_bgeff_intro": "Definisci un effetto/colore di sfondo, visualizzato durante l'\"inattività\" di HyperHDR. Inizia sempre con il canale di priorità 255.", "conf_effect_fgeff_intro": "Definire un effetto di avvio o un colore, che viene mostrato durante l'avvio di HyperHDR per la durata definita.", "conf_effect_path_intro": "Carica effetti dai percorsi definiti. Inoltre puoi disabilitare i singoli effetti per nome per nasconderli da tutti gli elenchi di effetti.", "conf_general_createInst_btn": "Crea istanza", - "conf_general_impexp_expbtn": "Esportare", - "conf_general_impexp_impbtn": "Importare", + "conf_general_impexp_expbtn": "Esporta", + "conf_general_impexp_impbtn": "Importa", "conf_general_impexp_l1": "Importa/esporta un backup della configurazione di TUTTE le istanze di HyperHDR. La password di accesso dell'utente non viene salvata ma alcuni dati sensibili potrebbero essere contenuti nelle impostazioni dell'istanza (ad esempio: chiave di accesso \"Philips Hue\").", "conf_general_impexp_l2": "Il formato del file di backup è compatibile con HyperHDR v17 e versioni successive.", "conf_general_impexp_title": "Importa/Esporta configurazione", "conf_general_inst_actionhead": "Azione", "conf_general_inst_delreq_h": "Elimina istanza hardware LED", - "conf_general_inst_delreq_t": "Sei sicuro di voler eliminare l'istanza \"$1\"? Anche tutte le impostazioni verranno eliminate.", + "conf_general_inst_delreq_t": "Sei sicuro di voler eliminare l'istanza \"$1\"? Verranno eliminate anche tutte le impostazioni.", "conf_general_inst_desc": "Usa hardware LED diverso contemporaneamente. Ogni istanza viene eseguita indipendentemente l'una dall'altra, il che consente diversi layout dei LED e impostazioni di calibrazione. Le istanze in esecuzione sono disponibili sull'icona a sinistra", "conf_general_inst_name_title": "Nome nuova istanza", "conf_general_inst_namehead": "Nome istanza", @@ -58,7 +58,7 @@ "conf_leds_layout_checkp4": "Case Gap: per creare un gap, ignoralo prima quando definisci Alto/Basso/Sinistra/Destra e imposta successivamente la lunghezza del gap per rimuovere una quantità di led. Modificare la posizione dello spazio finché non corrisponde.", "conf_leds_layout_cl_bottom": "Metter il fondo a", "conf_leds_layout_cl_bottomleft": "In basso a sinistra (angolo)", - "conf_leds_layout_cl_bottomright": "Angolo in basso a destra)", + "conf_leds_layout_cl_bottomright": "In basso a destra (angolo)", "conf_leds_layout_cl_cornergap": "Spazio d'angolo", "conf_leds_layout_cl_edgegap": "Spazio sul bordo", "conf_leds_layout_cl_gaglength": "Lunghezza del gioco", @@ -76,8 +76,8 @@ "conf_leds_layout_cl_rightmiddle": "Destra: 25 - 75% dall'alto", "conf_leds_layout_cl_righttop": "Destra: 0 - 50% dall'alto", "conf_leds_layout_cl_top": "Superiore", - "conf_leds_layout_cl_topleft": "Angolo in alto a sinistra)", - "conf_leds_layout_cl_topright": "Angolo in alto a destra)", + "conf_leds_layout_cl_topleft": "In alto a sinistra (angolo)", + "conf_leds_layout_cl_topright": "In alto a destra (angolo)", "conf_leds_layout_cl_vleddepth": "Profondità LED verticale", "conf_leds_layout_frame": "Layout classico (cornice LED)", "conf_leds_layout_generatedconf": "Configurazione LED generata/corrente", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Dispositivo di acquisizione del suono", "edt_conf_sound_device_expl": "Dispositivo di acquisizione del suono di sistema per plug-in che utilizzano la visualizzazione della musica", "available_sound_devices": "Dispositivi di acquisizione del suono disponibili", - "edt_conf_smooth_antiFlickeringTreshold_title": "Valore soglia anti-sfarfallio", - "edt_conf_smooth_antiFlickeringTreshold_expl": "I lettori video o i contenuti video compressi introducono un dithering casuale durante la riproduzione di filmati. Sebbene i cambiamenti nel valore RGB possano essere piccoli, possono causare effetti di sfarfallio sul sistema ambilight su scene scure. Ad esempio, la modifica di uno dei valori RGB di 1-3 dal dithering ha un piccolo effetto visivo sulle scene luminose, ma in condizioni di scarsa illuminazione è piuttosto drammatico. È possibile abilitare il sistema antisfarfallio per la modalità di scarsa illuminazione e impostare una soglia per applicare il filtro per evitare tale situazione per RGB al di sotto di tale valore. I led luminosi con RGB al di sopra di tale soglia non vengono toccati dal filtro. Funziona meglio con retroilluminazione minima colorata nella scheda di elaborazione.
Se si verifica uno sfarfallio su un film statico/in pausa, il problema è probabilmente di natura elettrica e tale opzione non sarà di aiuto.(0 = l'opzione è disabilitata, altrimenti il valore proposto è 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Anti-sfarfallio passo minimo", - "edt_conf_smooth_antiFlickeringValue_expl": "Cambio minimo richiesto del canale del colore (promemoria: l'intervallo RGB completo è 0-255 ciascuno) che deve essere raggiunto per influenzare la sorgente LED. Il target nero RGB (0,0,0) lo omette per preservare lo spegnimento dei led se la retroilluminazione è disabilitata", "main_ledsim_btn_screenshot": "Immagine dello schermo", "edt_conf_enum_linear_alternative": "Lineare alternativo (più veloce)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Timeout anti-sfarfallio", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Consentono di cambiare il colore di un led RGB, dopo un tempo personalizzato in millisecondi, anche se il passo è inferiore al minimo (0 = disabilitato, altrimenti il valore proposto è almeno 500 che dà 0.5 secondi)", "dashboard_current_video_device": "Dispositivo video", "dashboard_current_video_mode": "Modalità video", "general_comp_HDR": "HDR (globale)", @@ -1274,13 +1268,13 @@ "edt_conf_enum_warm": "Caldo", "edt_conf_enum_interpolator_Stepper_title": "Interpolatore Lineare", "edt_conf_enum_interpolator_Stepper_expl": "L'interpolatore lineare è un adattamento di un algoritmo legacy delle precedenti versioni di HyperHDR, riscritto per utilizzare l'aritmetica in virgola mobile per una maggiore precisione. Funziona interpolando linearmente il colore corrente verso un colore target, garantendo che la transizione venga completata in una durata definita indipendentemente dal frame rate. La sua caratteristica principale è la capacità di ritargettizzare in modo fluido a metà animazione, avviando una nuova transizione di durata completa dallo stato corrente verso il nuovo obiettivo.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolatore RGB Infinito", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolatore RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Questo algoritmo anima in modo fluido i colori RGB per una durata predefinita, offrendo due modalità distinte per la transizione. La prima è un'interpolazione lineare diretta per un percorso rettilineo tra i colori, mentre la seconda è una modalità levigata in cui il colore corrente 'insegue' elegantemente il colore target per creare un effetto di entrata/uscita graduale. Una caratteristica fondamentale è la sua capacità di ridimensionare in modo intelligente la durata di un'animazione quando viene interrotta, garantendo una velocità di cambiamento percettivamente costante.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolatore Infinito YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolatore YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Questo algoritmo interpola in modo fluido i colori operando nello spazio colore YUV per transizioni percettivamente più uniformi. La sua caratteristica principale è la limitazione della velocità di variazione della luminanza in ogni passaggio, evitando lampi di luminosità improvvisi e fastidiosi. Questo garantisce un effetto visivamente gradevole, anche se prolunga l'animazione oltre la durata inizialmente impostata per mantenere tale fluidità.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolatore Infinito Fisico Ibrido (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolatore Infinite Fisico Ibrido (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Questo algoritmo esegue transizioni fluide tra i colori utilizzando un modello fisico ibrido. Un 'pacer' lineare definisce il percorso diretto e la temporizzazione verso il colore di destinazione, mentre il colore di output effettivo segue questo pacer come un oggetto attaccato a una molla smorzata. Questo approccio in due parti crea animazioni fluide e dall'aspetto naturale con inerzia e overshoot personalizzabili, il tutto operando nello spazio colore YUV percettivamente uniforme.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolatore Infinito Fisico Ibrido (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolatore Infinite Fisico Ibrido (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Questo algoritmo esegue transizioni fluide tra i colori utilizzando un modello fisico ibrido. Un 'pacer' lineare definisce il percorso diretto e la tempistica per raggiungere il colore di destinazione, mentre il colore di output effettivo segue questo pacer come un oggetto attaccato a una molla smorzata. Questo approccio in due parti crea animazioni fluide e dall'aspetto naturale con inerzia e overshoot personalizzabili, il tutto operando nello spazio colore RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Fattore di Smoothing", "edt_conf_enum_interpolator_smoothingFactor_expl": "Il parametro determina l'aspetto dell'animazione, controllando la modalità di transizione tra i colori. Accetta un valore compreso tra 0.0 e 1.0, dove 0.0 determina una modifica diretta e lineare. Valori più elevati introducono una maggiore uniformità, creando un movimento fluido di 'inseguimento' mentre il colore corrente è leggermente in ritardo rispetto alla posizione ideale.", @@ -1291,7 +1285,7 @@ "edt_conf_enum_interpolator_y_limit_title": "Limitatore di variazione della luminosità", "edt_conf_enum_interpolator_y_limit_expl": "Questo parametro imposta un limite assoluto di quanto la luminosità (il canale Y in YUV) può variare in un singolo passaggio di aggiornamento. Agisce come un limite rigido che può ignorare la fisica della molla, prevenendo flash fastidiosi o effetti stroboscopici durante le transizioni rapide tra colori molto scuri e molto chiari. Impostando questo valore su un piccolo valore positivo si garantiscono rampe di luminosità molto fluide, mentre impostandolo su zero si disattiva completamente il limite.", "edt_conf_color_backlightThreshold_title": "Livello minimo di retroilluminazione", - "edt_conf_color_backlightThreshold_expl": "Livello minimo di luminosità (scala 0-1.0). Ogni intervallo di 0.0039(2) corrisponde a 1 nella scala 0-255. Disattivato durante effetti, colori e in stato \"Off\". + "edt_conf_color_backlightThreshold_expl": "Livello minimo di luminosità (scala 0-1.0). Ogni intervallo di 0.0039(2) corrisponde a 1 nella scala 0-255. Disattivato durante effetti, colori e in stato \"Off\"", "edt_conf_color_channelAdjustment_header_title": "Motore di colori infinito", "edt_conf_color_channelAdjustment_header_expl": "Crea profili colore che possono essere assegnati a un componente specifico. Regola colore, gamma, luminanza, saturazione e altro ancora. Calcoli ad alta precisione (float) utilizzati per l'elaborazione del colore.", "edt_conf_color_classic_config_title": "Calibrazione RGB", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Moltiplica le componenti di colore RGB per un dato fattore nello spazio RGB lineare.", "edt_conf_processing_powerLimit_title": "Limita potenza in uscita", "edt_conf_processing_powerLimit_expl": "Questa funzione verifica se il consumo energetico totale per la scena corrente è stato superato. In tal caso, riduce automaticamente la luminosità e il colore di ciascun LED. Nota: questa funzione non sostituisce un alimentatore sufficientemente potente. Questa funzione è progettata solo per limitare la luminosità eccessiva e non protegge l'apparecchiatura da danni dovuti a un alimentatore sottodimensionato. Non garantiamo che questa funzione si traduca direttamente nella limitazione della potenza della configurazione LED a un valore di wattaggio specifico.", - "edt_conf_smoothing_testMode_expl": "Cambiamenti di colore improvvisi e ciclici per testare gli algoritmi di smoothing, output sulla console (su Windows, eseguire HyperHDR con il parametro -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolatore Esponenziale Infinito", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolatore esponenziale Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "L'implementazione esponenziale classica dello smoothing aggiorna i colori dei LED in base a un target, reagendo rapidamente a grandi differenze e rallentando man mano che si avvicinano al target, producendo transizioni di illuminazione ambientale fluide e naturali.", "edt_dev_spec_macAddress_title": "Indirizzo MAC", "wiz_lifx_error": "Impossibile trovare i dispositivi Lifx. Controllare i log HyperHDR.", "wiz_lifx_title": "Procedura guidata luci LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Convertire in RGB lineare" + "edt_dev_spec_convertToLinearRgb_title": "Convertire in RGB lineare", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtro anti-sfarfallio", + "edt_conf_smooth_antiFlickeringFilter_expl": "Abilita un filtro Infinite Color Engine che riduce il sottile sfarfallio dei LED causato dalla quantizzazione del colore RGB a 24 bit. I controller che supportano formati di colore estesi (deep color), come Philips Hue (in modalità Entertainment) o i dispositivi LIFX, non hanno affatto bisogno di questo filtro." } diff --git a/www/i18n/nl.json b/www/i18n/nl.json index dfdff8314..62ff1877d 100644 --- a/www/i18n/nl.json +++ b/www/i18n/nl.json @@ -10,11 +10,11 @@ "InfoDialog_lang_title": "Taalinstelling", "InfoDialog_nowrite_foottext": "De WebUI wordt automatisch ontgrendeld nadat je het probleem hebt opgelost!", "InfoDialog_nowrite_text": "HyperHDR kan niet schrijven naar uw huidige geladen configuratiebestand. Herstel de bestandsrechten om door te gaan.", - "InfoDialog_nowrite_title": "schrijf toestemming fout!", + "InfoDialog_nowrite_title": "Schrijf-permissiefout!", "about_3rd_party_licenses": "Licenties van derden", "about_3rd_party_licenses_error": "We hadden problemen met het verzamelen van informatie over licenties van derden van internet.
Volg deze link naar de GitHub-bron.", - "about_build": "Bouwen", - "about_builddate": "Bouwdatum", + "about_build": "Build bron", + "about_builddate": "Build datum", "about_contribute": "Ontwikkel samen met ons HyperHDR verder!", "about_credits": "Credits aan al deze ontwikkelaars!", "about_resources": "$1 bibliotheken", @@ -39,7 +39,7 @@ "conf_general_inst_name_title": "Naam nieuwe instantie", "conf_general_inst_namehead": "Instantienaam", "conf_general_inst_renreq_t": "Voer in het onderstaande veld een nieuwe naam in voor uw instantie.", - "conf_general_inst_title": "Beheer van led-hardware-instanties", + "conf_general_inst_title": "Beheer van LED-hardware-instanties", "conf_general_intro": "Basissettingen gerelateerd aan HyperHDR en de WebUI die niet in andere categorieën passen.", "conf_general_label_title": "Algemene instellingen", "conf_grabber_fg_intro": "Platformopname is uw lokale systeemopname als invoerbron, waarop HyperHDR is geïnstalleerd.", @@ -57,8 +57,8 @@ "conf_leds_layout_checkp3": "Zorg ervoor dat de richting goed is. De grijze LED's geven LED nummer 2 en 3 aan om de datarichting te visualiseren.", "conf_leds_layout_checkp4": "Case Gap: Om een gap te creëren, negeer deze eerst wanneer je Top/Bottom/Left/Right definieert en stel daarna je gap lengte in om een aantal leds te verwijderen. Wijzig de positie van de opening totdat deze overeenkomt.", "conf_leds_layout_cl_bottom": "Onderkant", - "conf_leds_layout_cl_bottomleft": "Onderste hoek links)", - "conf_leds_layout_cl_bottomright": "Rechteronderhoek)", + "conf_leds_layout_cl_bottomleft": "Linksonder (hoek)", + "conf_leds_layout_cl_bottomright": "Rechtsonder (hoek)", "conf_leds_layout_cl_cornergap": "Hoekopening", "conf_leds_layout_cl_edgegap": "Randopening", "conf_leds_layout_cl_gaglength": "spleet lengte", @@ -76,8 +76,8 @@ "conf_leds_layout_cl_rightmiddle": "Rechts: 25 - 75% vanaf boven", "conf_leds_layout_cl_righttop": "Rechts: 0 - 50% vanaf boven", "conf_leds_layout_cl_top": "Bovenkant", - "conf_leds_layout_cl_topleft": "Bovenin de linker hoek)", - "conf_leds_layout_cl_topright": "Rechter bovenhoek)", + "conf_leds_layout_cl_topleft": "Linksboven (hoek)", + "conf_leds_layout_cl_topright": "Rechtsboven (hoek)", "conf_leds_layout_cl_vleddepth": "Verticale LED-diepte", "conf_leds_layout_frame": "Klassieke lay-out (LED-frame)", "conf_leds_layout_generatedconf": "Gegenereerde/huidige LED-configuratie", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Geluidsopnameapparaat", "edt_conf_sound_device_expl": "Apparaat voor het vastleggen van systeemgeluid voor plug-ins met behulp van muziekvisualisatie", "available_sound_devices": "Beschikbare apparaten voor het vastleggen van geluid", - "edt_conf_smooth_antiFlickeringTreshold_title": "Drempelwaarde tegen flikkeren", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Videospelers of gecomprimeerde video-inhoud introduceren wat willekeurige dithering tijdens het afspelen van films. Hoewel veranderingen in de RGB-waarde klein kunnen zijn, kunnen ze bij donkere scènes een flikkerend effect op uw Ambilight-systeem veroorzaken. Het veranderen van een RGB-waarde met 1-3 van dithering heeft bijvoorbeeld een klein visueel effect op heldere scènes, maar bij weinig licht is het behoorlijk dramatisch. U kunt het antiflikkersysteem inschakelen voor de modus voor weinig licht en een drempel instellen om een filter toe te passen om die situatie voor RGB onder een dergelijke waarde te voorkomen. Heldere leds met RGB boven een dergelijke drempel worden niet aangeraakt door het filter. Werkt het beste met minimale gekleurde achtergrondverlichting op het tabblad Processing.
Als u flikkeringen ervaart bij statische/gepauzeerde film, heeft uw probleem waarschijnlijk een elektrisch karakter en zal die optie niet helpen. (0 = de optie is uitgeschakeld, anders voorgestelde waarde is 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Anti-flikkerende minimale stap", - "edt_conf_smooth_antiFlickeringValue_expl": "Minimaal vereiste verandering van het kleurkanaal (herinnering: het volledige RGB-bereik is 0-255 elk) die moet worden bereikt om de LED-bron te beïnvloeden. RGB zwart doel (0,0,0) laat dat weg om het uitschakelen van leds te behouden als de achtergrondverlichting is uitgeschakeld", "main_ledsim_btn_screenshot": "Schermafbeelding", "edt_conf_enum_linear_alternative": "Alternatief lineair (sneller)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Anti-flikkering time-out", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Sta toe om een RGB led-kleur te veranderen, na aangepaste tijd in milliseconden, zelfs als de stap onder het minimum is (0 = uitgeschakeld, anders is de voorgestelde waarde minstens 500 wat 0.5 seconden geeft)", "dashboard_current_video_device": "Videoapparaat", "dashboard_current_video_mode": "Videomodus", "general_comp_HDR": "HDR (wereldwijd)", @@ -1274,13 +1268,13 @@ "edt_conf_enum_warm": "Warm", "edt_conf_enum_interpolator_Stepper_title": "Lineaire interpolator", "edt_conf_enum_interpolator_Stepper_expl": "De lineaire interpolator is een aanpassing van een verouderd algoritme uit eerdere HyperHDR-versies, herschreven om drijvende-kommaberekeningen te gebruiken voor een hogere precisie. Het werkt door de huidige kleur lineair te interpoleren naar een doelkleur, waardoor de overgang binnen een bepaalde tijd wordt voltooid, ongeacht de framesnelheid. Het belangrijkste kenmerk is de mogelijkheid om halverwege de animatie soepel opnieuw te targeten en een nieuwe, volledige overgang te starten van de huidige status naar het nieuwe doel.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Infinite Interpolator", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolator RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Dit algoritme animeert RGB-kleuren soepel gedurende een bepaalde tijdsduur en biedt twee verschillende modi voor de overgang. De eerste is een directe lineaire interpolatie voor een recht pad tussen kleuren, terwijl de tweede een vloeiende modus is waarbij de huidige kleur het doel sierlijk 'achtervolgt' om een ​​'ease-in/ease-out'-effect te creëren. Een belangrijke functie is de mogelijkheid om de duur van een animatie intelligent aan te passen wanneer deze wordt onderbroken, waardoor een perceptueel constante veranderingssnelheid wordt gegarandeerd.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite Interpolator", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolator YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Dit algoritme interpoleert kleuren vloeiend door te werken in de YUV-kleurruimte voor meer perceptueel uniforme overgangen. De belangrijkste functie is het beperken van de snelheid van luminantieverandering in elke stap, waardoor plotselinge, storende flitsen van helderheid worden voorkomen. Dit zorgt voor een visueel aantrekkelijk effect, zelfs als de animatie langer duurt dan de oorspronkelijk ingestelde duur om die vloeiendheid te behouden.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Infinite Interpolator (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite-interpolator: hybride fysica met traagheid (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Dit algoritme zorgt voor vloeiende overgangen tussen kleuren met behulp van een hybride fysiek model. Een lineaire 'pacer' definieert het directe pad en de timing naar de doelkleur, terwijl de daadwerkelijke uitvoerkleur deze pacer volgt als een object dat aan een gedempte veer is bevestigd. Deze tweedelige aanpak creëert vloeiende, natuurlijk ogende animaties met aanpasbare traagheid en overshoot, terwijl het werkt in de perceptueel uniforme YUV-kleurruimte.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hybrid Physics Infinite Interpolator (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite-interpolator: hybride fysica met traagheid (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Dit algoritme maakt vloeiende overgangen tussen kleuren mogelijk met behulp van een hybride fysiek model. Een lineaire 'pacer' definieert het directe pad en de timing naar de doelkleur, terwijl de uiteindelijke uitvoerkleur deze pacer volgt als een object dat aan een gedempte veer is bevestigd. Deze tweedelige aanpak creëert vloeiende, natuurlijk ogende animaties met aanpasbare inertie en overshoot, en dat alles binnen de RGB-kleurruimte.", "edt_conf_enum_interpolator_smoothingFactor_title": "Smoothingfactor", "edt_conf_enum_interpolator_smoothingFactor_expl": "Deze parameter bepaalt de feel van de animatie en bepaalt hoe de overgangen tussen kleuren verlopen. Een waarde van 0.0 tot 1.0 is acceptabel, waarbij 0.0 resulteert in een directe, lineaire verandering. Hogere waarden zorgen voor meer smoothing, waardoor een vloeiende 'achtervolgende' beweging ontstaat, omdat de huidige kleur iets achterloopt op de ideale positie.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Vermenigvuldigt de RGB-kleurcomponenten met een bepaalde factor in de lineaire RGB-ruimte.", "edt_conf_processing_powerLimit_title": "Beperk het uitgangsvermogen", "edt_conf_processing_powerLimit_expl": "Deze functie controleert of het totale opgenomen vermogen voor de huidige scène is overschreden. Zo ja, dan worden de helderheid en kleur van elke LED automatisch verlaagd. Let op: dit is geen vervanging voor een voldoende krachtige voeding. Deze functie is alleen bedoeld om overmatige helderheid te beperken en beschermt uw apparatuur niet tegen schade door een te kleine voeding. We garanderen niet dat deze functie direct leidt tot het beperken van het vermogen van de LED-opstelling tot een specifiek wattage.", - "edt_conf_smoothing_testMode_expl": "Cyclische, plotselinge kleurveranderingen voor het testen van smoothing-algoritmen, uitvoer naar de console (in Windows: voer HyperHDR uit met de parameter -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponentiële oneindige interpolator", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolator exponentiële Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "De klassieke exponentiële implementatie van smoothing werkt de LED-kleuren bij in de richting van een doel, reageert snel op grote verschillen en vertraagt ​​naarmate de kleuren het doel naderen, wat zorgt voor vloeiende, natuurlijke overgangen in de omgevingsverlichting.", "edt_dev_spec_macAddress_title": "MAC-adres", "wiz_lifx_error": "Lifx-apparaten niet gevonden. Controleer de HyperHDR-logs.", "wiz_lifx_title": "LIFX-lampenwizard", - "edt_dev_spec_convertToLinearRgb_title": "Omzetten naar lineair RGB" + "edt_dev_spec_convertToLinearRgb_title": "Omzetten naar lineair RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Anti‑flikkerfilter", + "edt_conf_smooth_antiFlickeringFilter_expl": "Schakelt een Infinite Color Engine-filter in dat subtiele LED-flikkering vermindert veroorzaakt door 24-bits RGB-kleurkwantisering. Controllers die uitgebreide kleurformaten (deep color) ondersteunen, zoals Philips Hue (in Entertainment-modus) of LIFX-apparaten, hebben dit filter helemaal niet nodig." } diff --git a/www/i18n/pl.json b/www/i18n/pl.json index 60a5d40b0..ed157ee19 100644 --- a/www/i18n/pl.json +++ b/www/i18n/pl.json @@ -4,7 +4,7 @@ "InfoDialog_access_title": "Poziom ustawień", "InfoDialog_changePassword_success": "Hasło zostało pomyślnie zapisane!", "InfoDialog_changePassword_title": "Zmień hasło", - "InfoDialog_iswitch_text": "Jeśli uruchamiasz wielokrotne instancje HyperHDR w lokalnej sieci, możesz przełączać się między konfiguracjami sieciowymi. Wybierz poniżej instancję HyperHDR i przełącz!", + "InfoDialog_iswitch_text": "Jeśli uruchamiasz wiele instancji HyperHDR w lokalnej sieci, możesz przełączać się między konfiguracjami webowymi. Wybierz poniżej instancję HyperHDR i przełącz!", "InfoDialog_iswitch_title": "Przełącznik HyperHDR", "InfoDialog_lang_text": "Jeśli nie podoba Ci się wynik automatycznego wykrywania języka, możesz go tutaj zastąpić.", "InfoDialog_lang_title": "Ustawienie języka", @@ -13,16 +13,16 @@ "InfoDialog_nowrite_title": "błąd uprawnień do zapisu!", "about_3rd_party_licenses": "Licencje osób trzecich", "about_3rd_party_licenses_error": "Mieliśmy problemy ze zbieraniem informacji o licencjach innych firm z sieci.
Proszę kliknąć ten link do zasobu GitHub.", - "about_build": "Budować", - "about_builddate": "Data budowy", - "about_contribute": "Rozwijaj HyperHDR z nami dalej!", - "about_credits": "Kredyty dla wszystkich tych programistów!", + "about_build": "Źródło kompilacji", + "about_builddate": "Data kompilacji", + "about_contribute": "Współtwórz z nami HyperHDR!", + "about_credits": "Podziękowania dla wszystkich deweloperów!", "about_resources": "Biblioteki $1", "about_translations": "Tłumaczenia", "about_version": "Wersja", "conf_colors_blackborder_intro": "Pomiń czarne paski, gdziekolwiek się znajdują. Każdy tryb wykorzystuje inny algorytm wykrywania, który jest dostosowany do specjalnych sytuacji. Podnieś próg, jeśli to nie działa dla Ciebie.", "conf_colors_color_intro": "Utwórz jeden lub więcej profili kalibracji, dostosuj każdy kolor, jasność, linearyzację i nie tylko.", - "conf_colors_smoothing_intro": "Wygładzanie spłaszcza zmiany koloru/jasności, aby zmniejszyć denerwujące rozproszenie. Ustawienie częstotliwości aktualizacji wyższej niż możliwości sterownika taśmy LED może powodować opóźnienia i wąskie gardło przetwarzania.", + "conf_colors_smoothing_intro": "Wygładzanie (Smoothing) wyrównuje zmiany koloru i jasności, aby zredukować irytujące migotanie. Ustawienie częstotliwości aktualizacji wyższej niż możliwości sterownika taśmy LED może spowodować opóźnienia i wąskie gardło w przetwarzaniu danych.", "conf_effect_bgeff_intro": "Określ efekt/kolor tła, który jest wyświetlany podczas trybu \"bezczynności\" HyperHDR. Zawsze rozpoczyna się z kanałem priorytetowym 255.", "conf_effect_fgeff_intro": "Zdefiniuj efekt rozruchu lub kolor, który jest wyświetlany podczas uruchamiania HyperHDR przez określony czas.", "conf_effect_path_intro": "Wczytaj efekty ze zdefiniowanych ścieżek. Dodatkowo możesz wyłączyć pojedyncze efekty według nazwy, aby ukryć je na wszystkich listach efektów.", @@ -56,28 +56,28 @@ "conf_leds_layout_checkp2": "Układ jest zawsze widokiem z przodu telewizora, nigdy z tyłu.", "conf_leds_layout_checkp3": "Upewnij się, że kierunek jest właściwy. Szare diody LED wskazują diody LED numer 2 i 3 w celu wizualizacji kierunku danych.", "conf_leds_layout_checkp4": "Case Gap: Aby utworzyć przerwę, zignoruj ją najpierw podczas definiowania Top/Bottom/Left/Right, a następnie ustaw długość przerwy, aby usunąć ilość diod led. Zmodyfikuj pozycję odstępu, aż będzie pasować.", - "conf_leds_layout_cl_bottom": "Spód", - "conf_leds_layout_cl_bottomleft": "Lewy dolny róg)", - "conf_leds_layout_cl_bottomright": "Dolny prawy róg)", + "conf_leds_layout_cl_bottom": "Dół", + "conf_leds_layout_cl_bottomleft": "Lewy dolny (róg)", + "conf_leds_layout_cl_bottomright": "Dolny prawy (róg)", "conf_leds_layout_cl_cornergap": "Szczelina narożna", "conf_leds_layout_cl_edgegap": "Szczelina na krawędzi", "conf_leds_layout_cl_gaglength": "Długość szczeliny", - "conf_leds_layout_cl_gappos": "pozycja przerwy", + "conf_leds_layout_cl_gappos": "Pozycja przerwy", "conf_leds_layout_cl_hleddepth": "Pozioma głębokość LED", "conf_leds_layout_cl_inppos": "Pozycja wejścia", "conf_leds_layout_cl_left": "Lewo", "conf_leds_layout_cl_leftbottom": "Po lewej: 50 - 100% od góry", "conf_leds_layout_cl_leftmiddle": "Po lewej: 25 - 75% od góry", "conf_leds_layout_cl_lefttop": "Po lewej: 0 - 50% od góry", - "conf_leds_layout_cl_overlap": "Zachodzić na siebie", + "conf_leds_layout_cl_overlap": "Nakładanie", "conf_leds_layout_cl_reversdir": "Odwrotny kierunek", - "conf_leds_layout_cl_right": "Dobrze", + "conf_leds_layout_cl_right": "Prawo", "conf_leds_layout_cl_rightbottom": "Po prawej: 50 - 100% od góry", "conf_leds_layout_cl_rightmiddle": "Po prawej: 25 - 75% od góry", "conf_leds_layout_cl_righttop": "Po prawej: 0 - 50% od góry", - "conf_leds_layout_cl_top": "Szczyt", - "conf_leds_layout_cl_topleft": "Górny lewy róg)", - "conf_leds_layout_cl_topright": "Prawy górny róg)", + "conf_leds_layout_cl_top": "Góra", + "conf_leds_layout_cl_topleft": "Górny lewy (róg)", + "conf_leds_layout_cl_topright": "Prawy górny (róg)", "conf_leds_layout_cl_vleddepth": "Głębokość LED w pionie", "conf_leds_layout_frame": "Układ klasyczny (ramka LED)", "conf_leds_layout_generatedconf": "Wygenerowana/bieżąca konfiguracja LED", @@ -231,9 +231,9 @@ "edt_conf_color_leds_expl": "Przypisz tę regulację do wszystkich diod LED (*) lub tylko niektórych (0-24).", "edt_conf_color_magenta_title": "Magenta", "edt_conf_color_magenta_expl": "Skalibrowana wartość magenta.", - "edt_conf_color_red_title": "czerwony", + "edt_conf_color_red_title": "Czerwony", "edt_conf_color_red_expl": "Skalibrowana czerwona wartość.", - "edt_conf_color_white_title": "biały", + "edt_conf_color_white_title": "Biały", "edt_conf_color_white_expl": "Skalibrowana wartość bieli.", "edt_conf_color_yellow_title": "Żółty", "edt_conf_color_yellow_expl": "Skalibrowana żółta wartość.", @@ -257,7 +257,7 @@ "edt_conf_enum_bottom_up": "Od dołu do góry", "edt_conf_enum_brg": "BRG", "edt_conf_enum_color": "Kolor", - "edt_conf_enum_custom": "Zwyczaj", + "edt_conf_enum_custom": "Niestandardowe", "edt_conf_enum_decay": "Próchnica (nie używaj)", "edt_conf_enum_dl_error": "Błąd", "edt_conf_enum_dl_informational": "Informacyjne", @@ -806,7 +806,7 @@ "remote_input_sourceactiv_btn": "Źródło aktywne", "remote_input_status": "Stan/działanie", "remote_losthint": "Uwaga: Wszystkie zmiany zostaną utracone po ponownym uruchomieniu.", - "remote_maptype_intro": "Zwykle układ diod definiuje, która dioda LED obejmuje określony obszar obrazu, możesz to zmienić tutaj: $1", + "remote_maptype_intro": "Układ LED określa, którą część obrazu wykorzystuje każda dioda; tutaj możesz wybrać algorytm. $1", "remote_maptype_label": "Typ mapowania", "remote_maptype_label_multicolor_mean": "Wielobarwność", "remote_maptype_label_unicolor_mean": "Jednokolorowe", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Urządzenie do przechwytywania dźwięku", "edt_conf_sound_device_expl": "Urządzenie do przechwytywania dźwięku systemowego dla wtyczek z wykorzystaniem wizualizacji muzyki", "available_sound_devices": "Dostępne urządzenia do przechwytywania dźwięku", - "edt_conf_smooth_antiFlickeringTreshold_title": "Wartość progowa zapobiegająca migotaniu", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Odtwarzacze wideo lub skompresowane treści wideo wprowadzają pewien losowy dithering podczas odtwarzania filmów. Chociaż zmiany wartości RGB mogą być niewielkie, mogą powodować efekt migotania w systemie ambilight w ciemnych scenach. Na przykład zmiana jednej z wartości RGB o 1-3 z ditheringu ma niewielki efekt wizualny w jasnych scenach, ale przy słabym oświetleniu jest dość dramatyczna. Możesz włączyć system przeciwdziałania migotaniu dla trybu słabego oświetlenia i ustawić próg, aby zastosować filtr, aby uniknąć takiej sytuacji dla RGB poniżej tej wartości. Jasne diody z RGB powyżej takiego progu nie są dotykane przez filtr. Działa najlepiej z kolorowym minimalnym podświetleniem w zakładce przetwarzania.
Jeśli na filmie pojawia się migotanie obrazu statycznego/wstrzymanego, oznacza to, że problem ma prawdopodobnie charakter elektryczny i ta opcja nie pomoże.(0 = opcja jest wyłączona, w przeciwnym razie proponowana wartość jest 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Minimalny krok zapobiegający migotaniu", - "edt_conf_smooth_antiFlickeringValue_expl": "Minimalna wymagana zmiana kanału koloru (przypomnienie: pełny zakres RGB to 0-255 każdy), który musi zostać osiągnięty, aby wpłynąć na źródło LED. Czarny cel RGB (0,0,0) pomija to, aby zachować wyłączanie diod LED, jeśli podświetlenie jest wyłączone", "main_ledsim_btn_screenshot": "Zrzut ekranu", "edt_conf_enum_linear_alternative": "Alternatywny liniowy (szybszy)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Limit czasu zapobiegający migotaniu", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Pozwala zmienić kolor diody RGB po niestandardowym czasie w milisekundach, nawet jeśli krok jest poniżej minimum (0 = wyłączone, w przeciwnym razie proponowana wartość to co najmniej 500, co daje 0.5 sekundy)", "dashboard_current_video_device": "Urządzenie wideo", "dashboard_current_video_mode": "Tryb wideo", "general_comp_HDR": "HDR (globalny)", @@ -1222,8 +1216,8 @@ "edt_conf_monitor_nits_title": "Korekta jasności HDR", "edt_conf_monitor_nits_expl": "Docelowa jasność SDR używana do konwersji HDR na SDR. Jeśli wynosi 0, wyłącza sprzętową konwersję kolorów przy jednoczesnym zachowaniu przyspieszonego skalowania.", "edt_append_nits": "nits", - "edt_conf_gen_disableOnLocked_title": "Wyłącz, gdy jest zablokowany", - "edt_conf_gen_disableOnLocked_expl": "Wyłącz przetwarzanie, gdy użytkownik zablokuje system.", + "edt_conf_gen_disableOnLocked_title": "Wyłącz przy zablokowanym systemie lub wyłączonym monitorze", + "edt_conf_gen_disableOnLocked_expl": "Zatrzymuje działanie grabbera programowego podczas blokady systemu lub wyłączenia monitora.", "edt_conf_gen_disableLedsStartup_title": "Wyłącz diody LED przy uruchomieniu", "edt_conf_gen_disableLedsStartup_expl": "Wyłącz diody LED i wszystkie komponenty przy uruchomieniu, musisz je ponownie włączyć ręcznie na stronie głównej lub poprzez API JSON (komponent COMP_ALL).", "edt_conf_sound_device_smoothing_title": "Włącz wygładzanie", @@ -1233,12 +1227,12 @@ "option_calibration_classic": "Kalibracja przy użyciu systemu Windows z włączonym trybem HDR i przeglądarki internetowej.
Kalibrujemy LUT, biorąc pod uwagę grabber i Twój telewizor.", "video_calibration_overview": "1 Musisz ustawić format wideo swojego grabbera na MJPEG/YUV/NV12/P010. Inne formaty nie są obsługiwane.

2 Jeśli kalibrujesz przy użyciu Flatbuffers, musisz włączyć mapowanie tonów w jego ustawieniach. Obsługiwany jest tylko format wideo NV12.

3 Pliki testowe możesz pobrać tutaj: link. W swoim odtwarzaczu zacznij odtwarzać plik testowy. Powinieneś to zobaczyć w podglądzie wideo HyperHDR. Ekran testowy musi zajmować cały ekran i żadne zbędne elementy, takie jak menu odtwarzacza, nie mogą być widoczne.

4 Do kalibracji należy wybrać plik z 'hdr' w nazwie, chyba że system lub odtwarzacz automatycznie używa mapowania tonów SDR do HDR lub jeśli planujesz skalibrować sygnał SDR. W takim przypadku, aby dostosować się do takiego scenariusza, wybierz plik z 'sdr' w nazwie.

5 Ograniczony zakres formatu YUV420 zapewnia największą zgodność ze średnią do bardzo dobrej jakości i jest najpopularniejszy. Format YUV444 zapewnia najlepszą jakość, ale rzadko można znaleźć materiały zakodowane w tej formie.

6 Jeśli kalibrujesz przy użyciu systemu Windows 11 (używając przeglądarki internetowej lub odtwarzacza wideo jako źródła wideo), wyłącz funkcje takie jak 'Światło nocne', 'Automatyczne zarządzanie kolorami dla aplikacji' i 'Auto-HDR'. Nie zmieniaj balansu kolorów w sterowniku graficznym. Wyjście GFX powinno obsługiwać np. 10 lub 12-bitowy RGB w pełnym zakresie komputera.

7 Obliczenia są bardzo intensywne i obciążają Twój sprzęt! Możesz wyłączyć korekcję kolorów LCH, aby nieco zmniejszyć obciążenie.", "chk_calibration_debug": "Debugowanie", - "flatbuffers_nv12_quarter_of_frame_title": "Ćwiartka klatki dla NV12", + "flatbuffers_nv12_quarter_of_frame_title": "Skaluj rozmiar klatki NV12 do 25%", "flatbuffers_nv12_quarter_of_frame_expl": "Kodek NV12 zawiera cztery razy więcej informacji o jasności niż o kolorze. Ta opcja pozwala zmniejszyć obciążenie procesora poprzez zmniejszenie wysokości i szerokości klatki wideo o 2 bez utraty informacji o kolorze.", "chk_lchCorrection": "Korekcja kolorów LCH", "grabber_calibration_expl": "To narzędzie pozwala utworzyć nową skalibrowaną tabelę HDR LUT dla programu grabber (lub zewnętrznego źródła buforów płaskich) tak blisko rzeczywistych kolorów wejściowych, jak to możliwe.
Potrzebne jest źródło wideo HDR10, które może wyświetlić tę stronę internetową, na przykład: Windows 10 z włączoną funkcją HDR we właściwościach sterownika graficznego.
Podczas kalibracji ekran może migotać. Proces ten trwa zazwyczaj kilka minut na komputerze z systemem Windows i procesorem Intel 7 (w zależności od zasobów procesora hosta i liczby klatek na sekundę przechwytywania wideo).
Obliczenia są bardzo intensywne i obciążają Twój sprzęt Możesz wyłączyć korekcję kolorów LCH, aby nieco zmniejszyć obciążenie
Możesz monitorować postęp w dziennikach HyperHDR za pomocą przeglądarki z innego urządzenia.


1 Jeśli wszystko jest prawidłowo podłączone, ta strona powinna zostać wyświetlona na ekranie telewizora (jako zawartość HDR) i podgląd na żywo w HyperHDR (przechwytywany przez grabber).
2 Absolutnie minimalna rozdzielczość przechwytywania to 1280x720 (zweryfikujemy to). Zalecana to 1920x1080 YUV/NV12. Należy zachować proporcje 1920/1080.
3 Należy wyłączyć 'Skaluj rozmiar klatki do 25%' we właściwościach programu grabber, jeśli jest włączony.
4 Należy ustawić format wideo programu grabber na MJPEG/YUV/NV12/P010.
5 Przed uruchomieniem procesu należy przełączyć przeglądarkę WWW w tryb pełnoekranowy (klawisz F11, zweryfikujemy to).
6 Jeśli kalibrujesz za pomocą systemu Windows 11, wyłącz funkcje takie jak 'Światło nocne', 'Automatyczne zarządzanie kolorami dla aplikacji' i 'Auto-HDR'. Nie zmieniaj balansu kolorów w sterowniku graficznym. Wyjście GFX powinno obsługiwać np. 10 lub 12 bitów RGB w pełnym zakresie PC.

Po zakończeniu kalibracji nowy plik tabeli LUT (lut_lin_tables.3d) zostanie utworzony w katalogu domowym HyperHDR użytkownika i będzie natychmiast gotowy do użycia, gdy tylko włączysz mapowanie tonów HDR. Sprawdź dzienniki HyperHDR, aby uzyskać szczegółowe informacje.", "edt_automatic_tone_mapping_title": "Automatyczne mapowanie tonów", - "edt_automatic_tone_mapping_enable_explain": "Automatyczne sterowanie mapowaniem tonów jest dostępne tylko dla formatów wideo 'YUV/NV12/P010' z włączonym trybem 'Ćwiartka klatki'. Skonfiguruj je w ustawieniach przechwytywania USB.
Komponent automatycznie włączy mapowanie tonów, jeśli sygnał nie przekroczy skonfigurowanych poziomów progowych przez określony czas i wyłączy je natychmiast po ich przekroczeniu.
Następnie możesz sprawdzić, jaka wartość przekroczyła którykolwiek z progów, co faktycznie spowodowało wyłączenie mapowania tonów w dziennikach HyperHDR. A następnie ewentualnie dostosować konfigurację, jeśli generuje ona fałszywe zdarzenia wyłączenia mapowania tonów (próg zbyt niski) lub generuje niepotrzebne włączenie mapowania tonów w ciemnych scenach SDR (próg zbyt wysoki).", + "edt_automatic_tone_mapping_enable_explain": "Automatyczne sterowanie mapowaniem tonów jest dostępne tylko dla formatów wideo 'YUV/NV12/P010' z włączonym trybem 'Skaluj rozmiar klatki do 25%'. Skonfiguruj je w ustawieniach przechwytywania USB.
Komponent automatycznie włączy mapowanie tonów, jeśli sygnał nie przekroczy skonfigurowanych poziomów progowych przez określony czas i wyłączy je natychmiast po ich przekroczeniu.
Następnie możesz sprawdzić, jaka wartość przekroczyła którykolwiek z progów, co faktycznie spowodowało wyłączenie mapowania tonów w dziennikach HyperHDR. A następnie ewentualnie dostosować konfigurację, jeśli generuje ona fałszywe zdarzenia wyłączenia mapowania tonów (próg zbyt niski) lub generuje niepotrzebne włączenie mapowania tonów w ciemnych scenach SDR (próg zbyt wysoki).", "edt_automatic_tone_mapping_y_threshold_title": "Próg jasności (Y)", "edt_automatic_tone_mapping_y_threshold_expl": "Poziom jasności, który oddziela surowy, ciemny materiał HDR od sygnału SDR.", "edt_automatic_tone_mapping_u_threshold_title": "Próg niebieskiej chrominancji (U)", @@ -1274,14 +1268,14 @@ "edt_conf_enum_warm": "Ciepły", "edt_conf_enum_interpolator_Stepper_title": "Interpolator liniowy", "edt_conf_enum_interpolator_Stepper_expl": "Interpolator liniowy to adaptacja starszego algorytmu z poprzednich wersji HyperHDR, przepisana z wykorzystaniem arytmetyki zmiennoprzecinkowej dla większej precyzji. Działa poprzez liniową interpolację bieżącego koloru w kierunku koloru docelowego, zapewniając zakończenie przejścia w określonym czasie, niezależnie od liczby klatek na sekundę. Jego kluczową cechą jest możliwość płynnej zmiany celu w trakcie animacji, inicjując nowe, pełne przejście z bieżącego stanu do nowego celu.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Nieskończony interpolator RGB", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolator RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Ten algorytm płynnie animuje kolory RGB w określonym czasie, oferując dwa różne tryby przejścia. Pierwszy to bezpośrednia interpolacja liniowa dla prostej ścieżki między kolorami, a drugi to tryb wygładzony, w którym bieżący kolor płynnie 'podąża' za kolorem docelowym, tworząc efekt łagodnego przejścia. Kluczową cechą jest możliwość inteligentnego skalowania czasu trwania animacji w przypadku jej przerwania, zapewniając percepcyjnie stałą prędkość zmian.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Nieskończony interpolator YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolator YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Ten algorytm płynnie interpoluje kolory, operując w przestrzeni barw YUV, co zapewnia bardziej percepcyjnie jednorodne przejścia. Jego główną cechą jest ograniczenie tempa zmian luminancji w każdym kroku, zapobiegając nagłym, rażącym błyskom jasności. Zapewnia to wizualnie przyjemny efekt, nawet jeśli animacja zostanie wydłużona poza jej początkowo ustawiony czas trwania, aby zachować płynność.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Nieskończony interpolator Hybrid Physics (YUV)", - "edt_conf_enum_interpolator_HybridInterpolator_expl": "Ten algorytm płynnie przechodzi między kolorami, wykorzystując hybrydowy model fizyczny. Liniowy 'tempor' definiuje bezpośrednią ścieżkę i czas do koloru docelowego, podczas gdy rzeczywisty kolor wyjściowy podąża za tym tempem jak obiekt przymocowany do tłumionej sprężyny. To dwuetapowe podejście tworzy płynne, naturalnie wyglądające animacje z konfigurowalną bezwładnością i przeregulowaniem, a wszystko to działając w percepcyjnie jednorodnej przestrzeni barw YUV.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Nieskończony interpolator Hybrid Physics (RGB)", - "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Ten algorytm płynnie przechodzi między kolorami, wykorzystując hybrydowy model fizyczny. Liniowy 'tempor' definiuje bezpośrednią ścieżkę i czas do koloru docelowego, podczas gdy rzeczywisty kolor wyjściowy podąża za tym tempem niczym obiekt przymocowany do sprężyny z tłumieniem. To dwuetapowe podejście tworzy płynne, naturalnie wyglądające animacje z konfigurowalną bezwładnością i przeregulowaniem, a wszystko to działa w przestrzeni barw RGB.", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolator Infinite: hybrydowa fizyka z inercją (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_expl": "Ten algorytm płynnie przechodzi między kolorami, wykorzystując hybrydowy model fizyczny. Najpierw wyznaczana jest liniowa ścieżka oraz czas dojścia do koloru docelowego, a następnie rzeczywisty kolor wyjściowy podąża za tą ścieżką jak obiekt przymocowany do tłumionej sprężyny. Takie dwustopniowe podejście tworzy płynne, naturalnie wyglądające animacje z konfigurowalną bezwładnością i przeregulowaniem, działając w percepcyjnie jednorodnej przestrzeni barw YUV.", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolator Infinite: hybrydowa fizyka z inercją (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Ten algorytm płynnie przechodzi między kolorami, wykorzystując hybrydowy model fizyczny. Najpierw wyznaczana jest liniowa ścieżka oraz czas dojścia do koloru docelowego, a następnie rzeczywisty kolor wyjściowy podąża za tą ścieżką niczym obiekt przymocowany do sprężyny z tłumieniem. Takie dwustopniowe podejście tworzy płynne, naturalnie wyglądające animacje z konfigurowalną bezwładnością i przeregulowaniem, działając w przestrzeni barw RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Współczynnik wygładzania", "edt_conf_enum_interpolator_smoothingFactor_expl": "Parametr ten określa charakter animacji, kontrolując sposób, w jaki przechodzi ona między kolorami. Przyjmuje wartości od 0.0 do 1.0, gdzie 0.0 oznacza bezpośrednią, liniową zmianę. Wyższe wartości wprowadzają większe wygładzanie, tworząc płynny ruch 'goniący', ponieważ bieżący kolor nieznacznie odstaje od idealnego położenia.", "edt_conf_enum_interpolator_stiffness_title": "Sztywność", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Mnoży składowe koloru RGB przez zadany współczynnik w liniowej przestrzeni RGB.", "edt_conf_processing_powerLimit_title": "Ograniczenie mocy wyjściowej", "edt_conf_processing_powerLimit_expl": "Ta funkcja sprawdza, czy całkowity pobór mocy dla bieżącej sceny został przekroczony. Jeśli tak, automatycznie zmniejsza jasność i kolor każdej diody LED. Pamiętaj, że nie zastępuje to wystarczająco mocnego zasilacza. Ta funkcja służy jedynie do ograniczania nadmiernej jasności i nie chroni sprzętu przed uszkodzeniem spowodowanym zbyt słabym zasilaczem. Nie gwarantujemy, że ta funkcja bezpośrednio przełoży się na ograniczenie mocy zestawu diod LED do określonej wartości watów.", - "edt_conf_smoothing_testMode_expl": "Cykliczne, nagłe zmiany kolorów do testowania algorytmów wygładzania, wyjście do konsoli (w systemie Windows uruchom HyperHDR z parametrem -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Wykładniczy interpolator nieskończony", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolator wykładniczy Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Klasyczna wykładnicza implementacja wygładzania aktualizuje kolory diod LED w kierunku celu, szybko reagując na duże różnice i zwalniając w miarę zbliżania się do celu, zapewniając płynne, naturalne przejścia oświetlenia otoczenia.", "edt_dev_spec_macAddress_title": "Adres MAC", "wiz_lifx_error": "Nie znaleziono urządzeń Lifx. Sprawdź logi HyperHDR.", "wiz_lifx_title": "Kreator oświetlenia LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Konwertuj na liniowe RGB" + "edt_dev_spec_convertToLinearRgb_title": "Konwertuj na liniowe RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtr przeciwmigotaniowy", + "edt_conf_smooth_antiFlickeringFilter_expl": "Włącza filtr Infinite Color Engine, który redukuje subtelne migotanie diod LED spowodowane 24-bitową kwantyzacją kolorów RGB. Kontrolery obsługujące rozszerzone formaty kolorów (deep color), takie jak Philips Hue (w trybie Entertainment) lub urządzenia LIFX, w ogóle nie potrzebują tego filtra." } diff --git a/www/i18n/ro.json b/www/i18n/ro.json index 96d826562..7eb133869 100644 --- a/www/i18n/ro.json +++ b/www/i18n/ro.json @@ -13,11 +13,11 @@ "InfoDialog_nowrite_title": "Eroare permisiune scriere!", "about_3rd_party_licenses": "Licențe terță parte", "about_3rd_party_licenses_error": "Am avut probleme la colectarea informațiilor privind licențele terților de pe web.
Vă rugăm să urmați acest link către resursa GitHub.", - "about_build": "Construi", + "about_build": "Sursă build", "about_builddate": "Data constructiei", "about_contribute": "Dezvoltă HyperHDR în continuare cu noi!", "about_credits": "Credite pentru toți acești dezvoltatori!", - "about_resources": "$1 biblioteci", + "about_resources": "Biblioteci $1", "about_translations": "Traduceri", "about_version": "Versiune", "conf_colors_blackborder_intro": "Sari peste bare negre oriunde s-ar afla. Fiecare mod folosește un alt algoritm de detectare care este reglat pentru situații speciale. Creșteți pragul dacă nu funcționează pentru dvs.", @@ -267,7 +267,7 @@ "edt_conf_enum_dl_verbose1": "Nivelul 1 de verbozitate", "edt_conf_enum_dl_verbose2": "Nivelul 2 de verbozitate", "edt_conf_enum_dl_verbose3": "Nivelul 3 de verbozitate", - "edt_conf_enum_effect": "Efect", + "edt_conf_enum_effect": "Efect vizual", "edt_conf_enum_gbr": "GBR", "edt_conf_enum_grb": "GRB", "edt_conf_enum_hsv": "HSV", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Dispozitiv de captare a sunetului", "edt_conf_sound_device_expl": "Dispozitiv de captare a sunetului de sistem pentru pluginuri folosind vizualizarea muzicii", "available_sound_devices": "Dispozitive de captare a sunetului disponibile", - "edt_conf_smooth_antiFlickeringTreshold_title": "Valoare prag anti-pâlpâire", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Playerele video sau conținutul video comprimat introduc unele ditheringuri aleatorii în timpul redării filmelor. Deși modificările valorii RGB pot fi mici, ele pot provoca un efect pâlpâitor asupra sistemului dvs. ambilight pe scene întunecate. De exemplu, schimbarea uneia dintre valoarea RGB cu 1-3 din dithering are un efect vizual mic pe scenele luminoase, dar la lumină slabă este destul de dramatic. Puteți activa sistemul antiflicker pentru modul de lumină slabă și puteți seta un prag pentru a aplica filtrul pentru a evita acea situație pentru RGB sub o astfel de valoare. Ledurile luminoase cu RGB peste acest prag nu sunt atinse de filtru. Funcționează cel mai bine cu lumina de fundal minimă colorată în fila de procesare.
Dacă aveți pâlpâire în filmul static/întrerupt, atunci problema dvs. are probabil natura electrică și opțiunea nu va ajuta. (0 = opțiunea este dezactivată, altfel valoarea propusă este 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Pas minim anti-pâlpâire", - "edt_conf_smooth_antiFlickeringValue_expl": "Schimbarea minimă necesară a canalului de culoare (memento: gama RGB completă este 0-255 fiecare) care trebuie atinsă pentru a afecta sursa LED. Ținta neagră RGB (0,0,0) omite aceea pentru a păstra ledurile de oprire dacă iluminarea din spate este dezactivată", "main_ledsim_btn_screenshot": "Captură de ecran", "edt_conf_enum_linear_alternative": "Alternativ liniar (mai rapid)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Timp de expirare anti-pâlpâire", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Permiteți schimbarea culorii ledului RGB, după timpul personalizat în milisecunde, chiar dacă pasul este sub minim (0 = dezactivat, altfel valoarea propusă este de cel puțin 500, ceea ce dă 0.5 secunde)", "dashboard_current_video_device": "Dispozitiv video", "dashboard_current_video_mode": "Mod video", "general_comp_HDR": "HDR (global)", @@ -1274,13 +1268,13 @@ "edt_conf_enum_warm": "Cald", "edt_conf_enum_interpolator_Stepper_title": "Interpolator liniar", "edt_conf_enum_interpolator_Stepper_expl": "Interpolatorul liniar este o adaptare a unui algoritm moștenit din versiunile anterioare de HyperHDR, rescris pentru a utiliza aritmetica în virgulă mobilă pentru o precizie mai mare. Funcționează prin interpolarea liniară a culorii curente către o culoare țintă, asigurându-se că tranziția se finalizează pe o durată definită, indiferent de rata cadrelor. Caracteristica sa cheie este capacitatea de a redirecționa lin la mijlocul animației, inițiind o nouă tranziție de durată completă de la starea sa actuală către noul obiectiv.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolator RGB Infinit", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Interpolator RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Acest algoritm animează lin culorile RGB pe o durată setată, oferind două moduri distincte pentru tranziție. Primul este o interpolare liniară directă pentru o traiectorie dreaptă între culori, în timp ce al doilea este un mod netezit în care culoarea curentă 'urmărește' grațios ținta pentru a crea un efect de intrare/ieșire ușoară. O caracteristică cheie este capacitatea sa de a rescala inteligent durata unei animații atunci când este întreruptă, asigurând o viteză de schimbare perceptual constantă.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolator Infinit YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Interpolator YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Acest algoritm interpolează lin culorile operând în spațiul de culoare YUV pentru tranziții mai uniforme din punct de vedere perceptiv. Caracteristica sa principală este limitarea ratei de schimbare a luminanței în fiecare pas, prevenind flash-urile bruște și sacadate de luminozitate. Acest lucru asigură un efect plăcut vizual, chiar dacă se extinde animația dincolo de durata inițial setată pentru a menține acea netezime.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolator Infinit în Fizică Hibridă (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Interpolator Infinite: fizică hibridă cu inerție (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Acest algoritm efectuează tranziții line între culori folosind un model fizic hibrid. Un 'pacer' liniar definește calea directă și sincronizarea către culoarea țintă, în timp ce culoarea de ieșire reală urmează acest pacer ca un obiect atașat la un arc amortizat. Această abordare în două părți creează animații fluide, cu aspect natural, cu inerție și depășire personalizabile, toate acestea funcționând în spațiul de culoare YUV uniform din punct de vedere perceptiv.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolator Infinit în Fizică Hibridă (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Interpolator Infinite: fizică hibridă cu inerție (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Acest algoritm efectuează o tranziție lină între culori folosind un model fizic hibrid. Un 'pacer' liniar definește calea directă și sincronizarea către culoarea țintă, în timp ce culoarea de ieșire reală urmează acest pacer ca un obiect atașat la un arc amortizat. Această abordare în două părți creează animații fluide, cu aspect natural, cu inerție și depășire personalizabile, toate acestea funcționând în spațiul de culoare RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Factor de netezire", "edt_conf_enum_interpolator_smoothingFactor_expl": "Parametrul dictează senzația animației, controlând modul în care aceasta trece între culori. Acceptă o valoare de la 0.0 la 1.0, unde 0.0 are ca rezultat o schimbare directă, liniară. Valorile mai mari introduc o netezire mai accentuată, creând o mișcare fluidă de 'urmărire', deoarece culoarea curentă rămâne ușor în urma poziției ideale.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Înmulțește componentele culorii RGB cu un factor dat în spațiul RGB liniar.", "edt_conf_processing_powerLimit_title": "Limitare putere de ieșire", "edt_conf_processing_powerLimit_expl": "Această funcție verifică dacă a fost depășit consumul total de energie pentru scena curentă. Dacă da, reduce automat luminozitatea și culoarea fiecărui LED. Vă rugăm să rețineți că acest lucru nu înlocuiește o sursă de alimentare suficient de puternică. Această funcție este concepută doar pentru a limita luminozitatea excesivă și nu va proteja echipamentul de deteriorarea cauzată de o sursă de alimentare subdimensionată. Nu garantăm că această funcție se va traduce direct în limitarea puterii configurației LED la o anumită valoare a puterii.", - "edt_conf_smoothing_testMode_expl": "Schimbări ciclice bruște de culoare pentru testarea algoritmilor de netezire, ieșire către consolă (pe Windows rulați HyperHDR cu parametrul -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolator Exponențial Infinit", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Interpolator exponențial Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Implementarea exponențială clasică a netezirii actualizează culorile LED-urilor către o țintă, reacționând rapid la diferențe mari și încetinind pe măsură ce acestea se apropie de țintă, producând tranziții line și naturale ale iluminării ambientale.", "edt_dev_spec_macAddress_title": "Adresă MAC", "wiz_lifx_error": "Nu s-au găsit dispozitive Lifx. Verificați jurnalele HyperHDR.", "wiz_lifx_title": "Asistentul pentru lumini LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Convertiți în RGB liniar" + "edt_dev_spec_convertToLinearRgb_title": "Convertiți în RGB liniar", + "edt_conf_smooth_antiFlickeringFilter_title": "Filtru anti-pâlpâire", + "edt_conf_smooth_antiFlickeringFilter_expl": "Activează un filtru Infinite Color Engine care reduce pâlpâirea subtilă a LED-urilor cauzată de cuantizarea culorilor RGB pe 24 de biți. Controlerele care acceptă formate de culoare extinse (deep color), cum ar fi Philips Hue (în modul Entertainment) sau dispozitivele LIFX, nu au deloc nevoie de acest filtru." } diff --git a/www/i18n/ru.json b/www/i18n/ru.json index 7293c3f16..5730a3c92 100644 --- a/www/i18n/ru.json +++ b/www/i18n/ru.json @@ -10,14 +10,14 @@ "InfoDialog_lang_title": "Настройка языка", "InfoDialog_nowrite_foottext": "Веб-интерфейс будет разблокирован автоматически после того, как вы решите проблему!", "InfoDialog_nowrite_text": "HyperHDR не может записывать в текущий загруженный файл конфигурации. Чтобы продолжить, восстановите права доступа к файлу.", - "InfoDialog_nowrite_title": "ошибка разрешения на запись!", + "InfoDialog_nowrite_title": "Ошибка разрешения на запись!", "about_3rd_party_licenses": "Сторонние лицензии", "about_3rd_party_licenses_error": "У нас возникли проблемы со сбором информации о сторонних лицензиях из Интернета.
Перейдите по этой ссылке на ресурс GitHub.", - "about_build": "Сборка", + "about_build": "Источник сборки", "about_builddate": "Дата сборки", "about_contribute": "Развивайте HyperHDR вместе с нами!", "about_credits": "Благодарим всех этих разработчиков!", - "about_resources": "Библиотеки за $1", + "about_resources": "Библиотеки $1", "about_translations": "Переводы", "about_version": "Версия", "conf_colors_blackborder_intro": "Пропускайте черные полосы, где бы они ни были. В каждом режиме используется другой алгоритм обнаружения, который настраивается для особых ситуаций. Повысьте порог, если это вам не поможет.", @@ -56,9 +56,9 @@ "conf_leds_layout_checkp2": "Расположение телевизора всегда соответствует виду спереди, а не сзади.", "conf_leds_layout_checkp3": "Убедитесь, что направление правильное. Серые светодиоды обозначают светодиоды 2 и 3 для визуализации направления данных.", "conf_leds_layout_checkp4": "Case Gap: чтобы создать зазор, сначала проигнорируйте его, когда вы определите Верх/Низ/Левый/Правый, а затем установите длину зазора чтобы убрать количество светодиодов. Измените положение зазора до совпадения.", - "conf_leds_layout_cl_bottom": "Нижний", - "conf_leds_layout_cl_bottomleft": "Левый нижний (угол)", - "conf_leds_layout_cl_bottomright": "Правый нижний (угол)", + "conf_leds_layout_cl_bottom": "Нижняя сторона", + "conf_leds_layout_cl_bottomleft": "Нижний левый (угол)", + "conf_leds_layout_cl_bottomright": "Нижний правый (угол)", "conf_leds_layout_cl_cornergap": "Угловой зазор", "conf_leds_layout_cl_edgegap": "Зазор между краями", "conf_leds_layout_cl_gaglength": "Длина зазора", @@ -75,9 +75,9 @@ "conf_leds_layout_cl_rightbottom": "Справа: 50 - 100% сверху", "conf_leds_layout_cl_rightmiddle": "Справа: 25 - 75% сверху", "conf_leds_layout_cl_righttop": "Справа: 0 - 50% сверху", - "conf_leds_layout_cl_top": "Верхний", - "conf_leds_layout_cl_topleft": "В левом верхнем (углу)", - "conf_leds_layout_cl_topright": "В правом верхнем (углу)", + "conf_leds_layout_cl_top": "Верхняя сторона", + "conf_leds_layout_cl_topleft": "Верхний левый (угол)", + "conf_leds_layout_cl_topright": "Верхний правый (угол)", "conf_leds_layout_cl_vleddepth": "Глубина вертикального светодиода", "conf_leds_layout_frame": "Классическая компоновка (светодиодная рамка)", "conf_leds_layout_generatedconf": "Генерируемая/текущая конфигурация светодиода", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Устройство захвата звука", "edt_conf_sound_device_expl": "Системное устройство захвата звука для плагинов с визуализацией музыки.", "available_sound_devices": "Доступные устройства звукозаписи", - "edt_conf_smooth_antiFlickeringTreshold_title": "Пороговое значение защиты от мерцания", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Видеопроигрыватели или сжатый видеоконтент вносят случайный дизеринг при воспроизведении фильмов. Хотя изменения в значении RGB могут быть небольшими, они могут вызвать эффект мерцания на вашей системе Ambilight на темных сценах. Например, изменение одного из значений RGB на 1-3 от дизеринга дает небольшой визуальный эффект на ярких сценах, но при слабом освещении это довольно драматично. Вы можете включить систему защиты от мерцания для режима низкой освещенности и установить порог для применения фильтра, чтобы избежать этой ситуации для RGB ниже этого значения. Яркие светодиоды с RGB выше такого порога не тронуты фильтром. Лучше всего работает с цветной минимальной подсветкой на вкладке обработки.
Если вы испытываете мерцание при просмотре статического/приостановленного фильма, возможно, ваша проблема имеет электрический характер, и этот параметр не поможет. (0 = параметр отключен, в противном случае предлагается значение 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Минимальный шаг защиты от мерцания", - "edt_conf_smooth_antiFlickeringValue_expl": "Минимально необходимое изменение цветового канала (напоминание: полный диапазон RGB составляет 0-255 каждый), которое должно быть достигнуто, чтобы повлиять на источник светодиода. Черная цель RGB (0,0,0) опускает это, чтобы сохранить выключение светодиодов, если подсветка отключена.", "main_ledsim_btn_screenshot": "Скриншот", "edt_conf_enum_linear_alternative": "Альтернативный линейный (быстрее)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Таймаут анти-мерцания", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Разрешить изменять цвет светодиода RGB по истечении заданного времени в миллисекундах, даже если шаг ниже минимального (0 = отключено, в противном случае предлагаемое значение составляет не менее 500, что дает 0.5 секунды).", "dashboard_current_video_device": "Видео устройство", "dashboard_current_video_mode": "Видео режим", "general_comp_HDR": "HDR (глобальный)", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "Холодный", "edt_conf_enum_neutral": "Нейтральный", "edt_conf_enum_warm": "Тёплый", - "edt_conf_enum_interpolator_Stepper_title": "Линейный интерполятор", + "edt_conf_enum_interpolator_Stepper_title": "Интерполятор Линейный Infinite", "edt_conf_enum_interpolator_Stepper_expl": "Линейный интерполятор — это адаптация устаревшего алгоритма из предыдущих версий HyperHDR, переписанная для использования арифметики с плавающей точкой для повышения точности. Он работает путем линейной интерполяции текущего цвета к целевому, обеспечивая завершение перехода в течение заданной длительности независимо от частоты кадров. Его ключевой особенностью является возможность плавного перенацеливания в середине анимации, инициируя новый полноценный переход от текущего состояния к новой цели.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Бесконечный интерполятор RGB", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Интерполятор RGB Infinite", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Этот алгоритм плавно анимирует RGB-цвета в течение заданной длительности, предлагая два различных режима перехода. Первый — прямая линейная интерполяция для прямого пути между цветами, а второй — сглаженный режим, в котором текущий цвет плавно 'следует' за целевым, создавая эффект плавного перехода. Ключевой особенностью является способность интеллектуально масштабировать длительность анимации при прерывании, обеспечивая постоянную скорость изменения.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Бесконечный интерполятор YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Интерполятор YUV Infinite", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Этот алгоритм плавно интерполирует цвета, работая в цветовом пространстве YUV, обеспечивая более равномерные переходы. Его основная функция — ограничение скорости изменения яркости на каждом этапе, предотвращая резкие вспышки. Это обеспечивает визуально приятный эффект, даже если анимация длится дольше изначально заданной длительности, сохраняя плавность.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Гибридный физический бесконечный интерполятор (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Интерполятор Infinite: гибридная физика с инерцией (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Этот алгоритм плавно переходит между цветами, используя гибридную физическую модель. Линейный 'шаг' определяет прямой путь и синхронизацию целевого цвета, в то время как фактический выходной цвет следует этому шагу, подобно объекту, прикрепленному к демпфированной пружине. Этот двухэтапный подход создает плавные, естественные анимации с настраиваемой инерцией и перерегулированием, работая при этом в однородном для восприятия цветовом пространстве YUV.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Гибридный физический бесконечный интерполятор (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Интерполятор Infinite: гибридная физика с инерцией (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Этот алгоритм обеспечивает плавные переходы между цветами, используя гибридную физическую модель. Линейный 'шаг' определяет прямой путь и время достижения целевого цвета, а фактический выходной цвет следует за этим механизмом, подобно объекту, прикрепленному к демпфированной пружине. Такой двухэтапный подход создает плавные, естественно выглядящие анимации с настраиваемой инерцией и перерегулированием, работая при этом в цветовом пространстве RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Коэффициент сглаживания", "edt_conf_enum_interpolator_smoothingFactor_expl": "Этот параметр определяет ощущение анимации, управляя переходами между цветами. Он принимает значения от 0.0 до 1.0, где 0.0 соответствует прямому линейному изменению. Более высокие значения усиливают сглаживание, создавая плавное 'преследование' движения, когда текущий цвет немного отстаёт от идеального положения.", @@ -1292,7 +1286,7 @@ "edt_conf_enum_interpolator_y_limit_expl": "Этот параметр устанавливает абсолютный предел изменения яркости (канала Y в YUV) за один шаг обновления. Он действует как жёсткий предел, который может переопределять физику пружины, предотвращая резкие вспышки или стробоскопические эффекты при резких переходах между очень тёмными и очень яркими цветами. Установка небольшого положительного значения обеспечивает очень плавное изменение яркости, а установка нуля полностью отключает предел.", "edt_conf_color_backlightThreshold_title": "Минимальный уровень подсветки", "edt_conf_color_backlightThreshold_expl": "Минимальный уровень яркости (шкала 0–1.0). Каждый шаг 0.0039(2) соответствует 1 по шкале 0–255. Отключено при использовании эффектов, цветов и в состоянии \"Выкл.\".", - "edt_conf_color_channelAdjustment_header_title": "Бесконечный цветовой модуль", + "edt_conf_color_channelAdjustment_header_title": "Infinite Color Engine", "edt_conf_color_channelAdjustment_header_expl": "Создание цветовых профилей, которые можно назначить определённому компоненту. Настройте цвет, гамму, яркость, насыщенность и другие параметры. Для обработки цвета используются высокоточные (плавающие) вычисления.", "edt_conf_color_classic_config_title": "Калибровка RGB", "edt_conf_color_classic_config_expl": "Калибровка по трём основным цветам (красный, зелёный, синий). Достаточно для большинства случаев.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Умножает компоненты цвета RGB на заданный коэффициент в линейном пространстве RGB.", "edt_conf_processing_powerLimit_title": "Ограничение выходной мощности", "edt_conf_processing_powerLimit_expl": "Эта функция проверяет, не превышена ли общая потребляемая мощность для текущей сцены. Если превышена, она автоматически уменьшает яркость и цвет каждого светодиода. Обратите внимание: это не заменяет достаточно мощный блок питания. Эта функция предназначена только для ограничения чрезмерной яркости и не защитит ваше оборудование от повреждения из-за недостаточно мощного блока питания. Мы не гарантируем, что эта функция напрямую ограничит мощность светодиодной системы определённым значением.", - "edt_conf_smoothing_testMode_expl": "Циклические резкие изменения цвета для тестирования алгоритмов сглаживания, вывод на консоль (в Windows запустите HyperHDR с параметром -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Экспоненциальный бесконечный интерполятор", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Интерполятор Экспоненциальный Infinite", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Классическая экспоненциальная реализация сглаживания обновляет цвета светодиодов в направлении целевой области, быстро реагируя на большие различия и замедляясь по мере приближения к целевой области, создавая плавные и естественные переходы между уровнями освещения.", "edt_dev_spec_macAddress_title": "MAC адрес", "wiz_lifx_error": "Не удалось найти устройства Lifx. Проверьте логи HyperHDR.", "wiz_lifx_title": "Мастер настройки освещения LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Преобразовать в линейное RGB" + "edt_dev_spec_convertToLinearRgb_title": "Преобразовать в линейное RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Фильтр анти-мерцания", + "edt_conf_smooth_antiFlickeringFilter_expl": "Включает фильтр Infinite Color Engine, который уменьшает тонкое мерцание светодиодов, вызванное 24-битным квантованием цветов RGB. Контроллеры, поддерживающие расширенные форматы цвета (deep color), такие как Philips Hue (в режиме Entertainment) или устройства LIFX, в этом фильтре вообще не нуждаются." } diff --git a/www/i18n/sv.json b/www/i18n/sv.json index 8d8203470..47326a994 100644 --- a/www/i18n/sv.json +++ b/www/i18n/sv.json @@ -10,10 +10,10 @@ "InfoDialog_lang_title": "Språk inställning", "InfoDialog_nowrite_foottext": "WebUI låses upp automatiskt när du löst problemet!", "InfoDialog_nowrite_text": "HyperHDR kan inte skriva till din nuvarande laddade konfigurationsfil. Reparera filtillstånden för att fortsätta.", - "InfoDialog_nowrite_title": "skrivbehörighetsfel!", + "InfoDialog_nowrite_title": "Skrivbehörighetsfel!", "about_3rd_party_licenses": "Tredjepartslicenser", "about_3rd_party_licenses_error": "Vi hade problem med att samla in tredjepartslicensinformation från webben.
Följ den här länken till GitHub -resursen.", - "about_build": "Bygga", + "about_build": "Byggkälla", "about_builddate": "Byggdatum", "about_contribute": "Utveckla HyperHDR vidare med oss!", "about_credits": "Tack till alla dessa utvecklare!", @@ -56,9 +56,9 @@ "conf_leds_layout_checkp2": "Layouten är alltid framsidan av din TV, aldrig baksidan.", "conf_leds_layout_checkp3": "Se till att riktningen är rätt. De grå lysdioderna indikerar LED nummer 2 och 3 för att visualisera datariktningen.", "conf_leds_layout_checkp4": "Case Gap: För att skapa en lucka, ignorera den först när du definierar Top/Bottom/Left/Right och ställer in därefter din gaplängd för att ta bort en mängd lysdioder. Ändra gappositionen tills den matchar.", - "conf_leds_layout_cl_bottom": "Botten", - "conf_leds_layout_cl_bottomleft": "Nedre vänster (hörn)", - "conf_leds_layout_cl_bottomright": "Nedre högra hörnet)", + "conf_leds_layout_cl_bottom": "Nederkant", + "conf_leds_layout_cl_bottomleft": "Nedre vänstra (hörn)", + "conf_leds_layout_cl_bottomright": "Nedre högra (hörn)", "conf_leds_layout_cl_cornergap": "Corner Gap", "conf_leds_layout_cl_edgegap": "Edge Gap", "conf_leds_layout_cl_gaglength": "Spaltlängd", @@ -76,8 +76,8 @@ "conf_leds_layout_cl_rightmiddle": "Höger: 25 - 75% från toppen", "conf_leds_layout_cl_righttop": "Höger: 0 - 50% från toppen", "conf_leds_layout_cl_top": "Topp", - "conf_leds_layout_cl_topleft": "Övre vänstra hörnet)", - "conf_leds_layout_cl_topright": "Översta högra hörnet)", + "conf_leds_layout_cl_topleft": "Övre vänstra (hörn)", + "conf_leds_layout_cl_topright": "Övre högra (hörn)", "conf_leds_layout_cl_vleddepth": "Vertikalt LED -djup", "conf_leds_layout_frame": "Klassisk layout (LED -ram)", "conf_leds_layout_generatedconf": "Genererad/nuvarande LED -konfiguration", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Ljudinspelningsenhet", "edt_conf_sound_device_expl": "System för ljudinspelning för plugins med musikvisualisering", "available_sound_devices": "Tillgängliga ljudinspelningsenheter", - "edt_conf_smooth_antiFlickeringTreshold_title": "Tröskelvärde mot flimrande", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Videospelare eller komprimerat videoinnehåll introducerar en del slumpmässiga ryck när du spelar filmer. Även om ändringar i RGB -värdet kan vara små kan de orsaka flimrande effekt på ditt ambilight -system på mörka scener. Till exempel att ändra ett av RGB-värdet med 1-3 från dithering har en liten visuell effekt på ljusa scener men vid svagt ljus är det ganska dramatiskt. Du kan aktivera antiflimmer -system för svagt ljus och ställa in en tröskel för att tillämpa filter för att undvika den situationen för RGB under sådant värde. Ljusa lysdioder med RGB över sådan tröskel berörs inte av filtret. Fungerar bäst med färgad minimal bakgrundsbelysning på bearbetningsfliken.
Om du upplever flimring på statisk/pausad film har ditt problem förmodligen elektrisk karaktär och det alternativet hjälper inte. (0 = alternativet är inaktiverat, annars föreslaget värde är 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Flimrande minimalt steg", - "edt_conf_smooth_antiFlickeringValue_expl": "Minimal ändring av färgkanal (påminnelse: fullt RGB-område är 0-255 vardera) som måste uppnås för att påverka LED-källan. RGB svart mål (0,0,0) utelämnar det för att bevara att stänga av lysdioder om bakgrundsbelysningen är inaktiverad", "main_ledsim_btn_screenshot": "Skärmdump", "edt_conf_enum_linear_alternative": "Alternativ linjär (snabbare)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Anti-flimrande timeout", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Tillåt att ändra en RGB -ledfärg efter anpassad tid i milisekunder, även om steget är under minimum (0 = inaktiverat, annars är föreslaget värde minst 500 vilket ger 0.5 sekunder)", "dashboard_current_video_device": "Videoenhet", "dashboard_current_video_mode": "Video läge", "general_comp_HDR": "HDR (globalt)", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "Kall", "edt_conf_enum_neutral": "Neutral", "edt_conf_enum_warm": "Varm", - "edt_conf_enum_interpolator_Stepper_title": "Linjär interpolator", + "edt_conf_enum_interpolator_Stepper_title": "Linjär Infinite-interpolator", "edt_conf_enum_interpolator_Stepper_expl": "Den linjära interpolatorn är en anpassning av en äldre algoritm från tidigare HyperHDR-versioner, omskriven för att använda flyttalsberäkning för högre precision. Den fungerar genom att linjärt interpolera den aktuella färgen mot en målfärg, vilket säkerställer att övergången slutförs under en definierad varaktighet oavsett bildhastighet. Dess viktigaste egenskap är möjligheten att smidigt omrikta mitt i animeringen och initiera en ny, fullvarig övergång från dess nuvarande tillstånd mot det nya målet.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Oändlig interpolator", + "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Infinite-interpolator", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Denna algoritm animerar smidigt RGB-färger under en inställd varaktighet och erbjuder två distinkta lägen för övergången. Det första är en direkt linjär interpolering för en rak väg mellan färger, medan det andra är ett utjämnat läge där den aktuella färgen elegant 'jagar' målet för att skapa en lättnads-in/ut-effekt. En viktig funktion är dess förmåga att intelligent skala om en animations varaktighet när den avbryts, vilket säkerställer en perceptuellt konstant förändringshastighet.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Oändlig Interpolator", + "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite-interpolator", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Denna algoritm interpolerar färger smidigt genom att arbeta i YUV-färgrymden för mer perceptuellt enhetliga övergångar. Dess huvudsakliga funktion är att begränsa hastigheten på luminansförändringen i varje steg, vilket förhindrar plötsliga, stötande ljusglimtar. Detta säkerställer en visuellt tilltalande effekt, även om den förlänger animationen bortom dess ursprungligen inställda varaktighet för att bibehålla den jämnheten.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Oändlig Interpolator (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite-interpolator: hybridfysik med tröghet (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Denna algoritm övergår smidigt mellan färger med hjälp av en hybrid fysisk modell. En linjär 'pacer' definierar den direkta vägen och tidpunkten till målfärgen, medan den faktiska utmatningsfärgen följer denna pacer som ett objekt fäst vid en dämpad fjäder. Denna tvådelade metod skapar flytande, naturligt utseende animationer med anpassningsbar tröghet och överskridning, allt medan den arbetar i det perceptuellt enhetliga YUV-färgrymden.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hybrid Physics Oändlig Interpolator (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite-interpolator: hybridfysik med tröghet (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Denna algoritm övergår smidigt mellan färger med hjälp av en hybrid fysisk modell. En linjär 'pacer' definierar den direkta vägen och tidpunkten till målfärgen, medan den faktiska utfärgen följer denna pacer som ett objekt fäst vid en dämpad fjäder. Denna tvådelade metod skapar flytande, naturligt utseende animationer med anpassningsbar tröghet och överskridning, allt medan den arbetar i RGB-färgrymden.", "edt_conf_enum_interpolator_smoothingFactor_title": "Utjämningsfaktor", "edt_conf_enum_interpolator_smoothingFactor_expl": "Parametern dikterar animationens känsla och styr hur den övergår mellan färger. Den accepterar ett värde från 0.0 till 1.0, där 0.0 resulterar i en direkt, linjär förändring. Högre värden introducerar mer utjämning, vilket skapar en flytande 'jagande' rörelse eftersom den aktuella färgen ligger något efter den ideala positionen.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Multiplicerar RGB-färgkomponenterna med en given faktor i det linjära RGB-utrymmet.", "edt_conf_processing_powerLimit_title": "Begränsa effektuttaget", "edt_conf_processing_powerLimit_expl": "Denna funktion kontrollerar om den totala effektförbrukningen för den aktuella scenen har överskridits. Om så är fallet skalar den automatiskt ner ljusstyrkan och färgen för varje LED. Observera att detta inte ersätter en tillräckligt kraftfull strömförsörjning. Den här funktionen är endast utformad för att begränsa överdriven ljusstyrka och skyddar inte din utrustning från skador på grund av en för liten strömförsörjning. Vi garanterar inte att den här funktionen direkt kommer att leda till att LED-installationens effekt begränsas till ett specifikt effektvärde.", - "edt_conf_smoothing_testMode_expl": "Cykliska plötsliga färgförändringar för utjämningsalgoritmtestning, utdata till konsolen (kör HyperHDR med -c-parametern på Windows).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponentiell oändlig interpolator", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponentiell Infinite-interpolator", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Klassisk exponentiell implementering av utjämning uppdaterar LED-färger mot ett mål, reagerar snabbt på stora skillnader och saktar ner när de närmar sig målet, vilket producerar mjuka, naturliga övergångar i omgivande ljus.", "edt_dev_spec_macAddress_title": "MAC-adress", "wiz_lifx_error": "Kunde inte hitta Lifx-enheter. Kontrollera HyperHDR-loggar.", "wiz_lifx_title": "LIFX-ljusguide", - "edt_dev_spec_convertToLinearRgb_title": "Konvertera till linjärt RGB" + "edt_dev_spec_convertToLinearRgb_title": "Konvertera till linjärt RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "Anti-flimmerfilter", + "edt_conf_smooth_antiFlickeringFilter_expl": "Aktiverar ett Infinite Color Engine-filter som reducerar subtilt LED-flimmer orsakat av 24-bitars RGB-färgkvantisering. Kontroller som stöder utökade färgformat (deep color), såsom Philips Hue (i Entertainment-läge) eller LIFX-enheter, behöver inte detta filter alls." } diff --git a/www/i18n/tr.json b/www/i18n/tr.json index 264f11e2a..aace9689d 100644 --- a/www/i18n/tr.json +++ b/www/i18n/tr.json @@ -10,14 +10,14 @@ "InfoDialog_lang_title": "Dil ayarı", "InfoDialog_nowrite_foottext": "Sorunu çözdükten sonra WebUI'nin kilidi otomatik olarak açılacaktır!", "InfoDialog_nowrite_text": "HyperHDR, mevcut yüklü yapılandırma dosyanıza yazamaz. Devam etmek için lütfen dosya izinlerini onarın.", - "InfoDialog_nowrite_title": "izin hatası yaz!", + "InfoDialog_nowrite_title": "Yazma izni hatası!", "about_3rd_party_licenses": "3. taraf lisansları", "about_3rd_party_licenses_error": "Web'den 3. taraf lisans bilgilerini toplamada sorun yaşadık.
Lütfen GitHub Kaynağına giden bu bağlantıyı takip edin.", - "about_build": "Yapı", - "about_builddate": "Kuruluş zamanı", + "about_build": "Yapı kaynağı", + "about_builddate": "Yapım tarihi", "about_contribute": "HyperHDR'yi bizimle daha da geliştirin!", "about_credits": "Tüm bu geliştiricilere teşekkür ederiz!", - "about_resources": "$1 kitaplık", + "about_resources": "$1 kütüphaneleri", "about_translations": "Çeviriler", "about_version": "Sürüm", "conf_colors_blackborder_intro": "Nerede olurlarsa olsunlar siyah çubukları atlayın. Her mod, özel durumlar için ayarlanmış başka bir algılama algoritması kullanır. İşinize yaramazsa eşiği yükseltin.", @@ -56,9 +56,9 @@ "conf_leds_layout_checkp2": "Düzen her zaman TV'nizin önden görünümüdür, asla arkadan görünümü değildir.", "conf_leds_layout_checkp3": "Yönün doğru olduğundan emin olun. Gri LED'ler, veri yönünü görselleştirmek için 2 ve 3 numaralı LED'i gösterir.", "conf_leds_layout_checkp4": "Case Gap: Bir boşluk oluşturmak için, önce Üst/Alt/Sol/Sağ tanımladığınızda bunu yok sayın ve daha sonra bir miktar led kaldırmak için boşluk uzunluğunuzu ayarlayın. Eşleşene kadar boşluk konumunu değiştirin.", - "conf_leds_layout_cl_bottom": "Alt", - "conf_leds_layout_cl_bottomleft": "Sol alt köşe)", - "conf_leds_layout_cl_bottomright": "Sağ Alt (Köşe)", + "conf_leds_layout_cl_bottom": "Alt kenar", + "conf_leds_layout_cl_bottomleft": "Sol alt (köşe)", + "conf_leds_layout_cl_bottomright": "Sağ alt (köşe)", "conf_leds_layout_cl_cornergap": "Köşe Boşluğu", "conf_leds_layout_cl_edgegap": "Kenar Boşluğu", "conf_leds_layout_cl_gaglength": "boşluk uzunluğu", @@ -75,9 +75,9 @@ "conf_leds_layout_cl_rightbottom": "Sağ: Üstten 50 - %100", "conf_leds_layout_cl_rightmiddle": "Sağ: Üstten 25 - %75", "conf_leds_layout_cl_righttop": "Sağ: Üstten 0 - %50", - "conf_leds_layout_cl_top": "Tepe", - "conf_leds_layout_cl_topleft": "Sol üst köşe)", - "conf_leds_layout_cl_topright": "Sağ üst köşe)", + "conf_leds_layout_cl_top": "Üst kenar", + "conf_leds_layout_cl_topleft": "Sol üst (köşe)", + "conf_leds_layout_cl_topright": "Sağ üst (köşe)", "conf_leds_layout_cl_vleddepth": "Dikey LED derinliği", "conf_leds_layout_frame": "Klasik Düzen (LED Çerçeve)", "conf_leds_layout_generatedconf": "Oluşturulan/Mevcut LED Yapılandırması", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Ses yakalama cihazı", "edt_conf_sound_device_expl": "Müzik görselleştirme kullanan eklentiler için sistem ses yakalama cihazı", "available_sound_devices": "Kullanılabilir ses yakalama cihazları", - "edt_conf_smooth_antiFlickeringTreshold_title": "Titreme önleyici eşik değeri", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Video oynatıcılar veya sıkıştırılmış video içeriği, film oynatılırken bazı rastgele renk taklidi yapar. RGB değerindeki değişiklikler küçük olsa da, karanlık sahnelerde ambilight sisteminizde titreme etkisine neden olabilir. Örneğin, RGB değerinden birinin renk taklidinden 1-3 kadar değiştirilmesi, parlak sahnelerde küçük bir görsel etkiye sahiptir, ancak düşük ışıkta oldukça dramatiktir. Düşük ışık modu için titreme önleme sistemini etkinleştirebilir ve bu değerin altındaki RGB için bu durumu önlemek için filtre uygulamak için bir eşik ayarlayabilirsiniz. Bu eşiğin üzerinde RGB'ye sahip parlak led'lere filtre tarafından dokunulmaz. İşleme sekmesindeki renkli minimum arka ışıkla en iyi sonucu verir.
Statik/duraklatılmış filmde titreme yaşıyorsanız, sorununuz muhtemelen elektrikseldir ve bu seçenek yardımcı olmaz.(0 = seçenek devre dışı, aksi takdirde önerilen değer 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Titreşim önleyici minimum adım", - "edt_conf_smooth_antiFlickeringValue_expl": "LED kaynağını etkilemek için ulaşılması gereken minimum renk kanalı değişikliği (hatırlatma: tam RGB aralığı her biri 0-255'tir). RGB siyah hedef (0,0,0), arka ışık devre dışı bırakıldığında ledleri kapatmayı korumak için bunu atlar", "main_ledsim_btn_screenshot": "Ekran görüntüsü", "edt_conf_enum_linear_alternative": "Alternatif doğrusal (daha hızlı)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Titreşimsiz zaman aşımı", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Adım minimumun altında olsa bile (0 = devre dışı, aksi takdirde önerilen değer en az 500'dir ve bu 0.5 saniye verir) özel süreden sonra RGB led rengini değiştirmeye izin ver", "dashboard_current_video_device": "video cihazı", "dashboard_current_video_mode": "Video modu", "general_comp_HDR": "HDR (küresel)", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "Soğuk", "edt_conf_enum_neutral": "Nötr", "edt_conf_enum_warm": "Sıcak", - "edt_conf_enum_interpolator_Stepper_title": "Doğrusal İnterpolatör", + "edt_conf_enum_interpolator_Stepper_title": "Doğrusal Infinite İnterpolatör", "edt_conf_enum_interpolator_Stepper_expl": "Doğrusal İnterpolatör, önceki HyperHDR sürümlerinden kalma bir algoritmanın, daha yüksek hassasiyet için kayan nokta aritmetiğini kullanacak şekilde yeniden yazılmış bir uyarlamasıdır. Mevcut rengi hedef renge doğru doğrusal olarak interpolasyon yaparak çalışır ve geçişin kare hızından bağımsız olarak belirli bir süre boyunca tamamlanmasını sağlar. Temel özelliği, animasyonun ortasında sorunsuz bir şekilde yeniden hedefleme ve mevcut durumundan yeni hedefe doğru yeni, tam süreli bir geçiş başlatma yeteneğidir.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Sonsuz İnterpolatör", + "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Infinite İnterpolatör", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Bu algoritma, RGB renklerini belirli bir süre boyunca sorunsuz bir şekilde canlandırır ve geçiş için iki farklı mod sunar. Birincisi, renkler arasında düz bir yol için doğrudan doğrusal interpolasyon, ikincisi ise mevcut rengin hedefi zarif bir şekilde 'kovalayarak' bir kolay giriş/kolay çıkış efekti oluşturduğu yumuşatılmış bir moddur. Temel özelliklerinden biri, kesintiye uğradığında animasyonun süresini akıllıca yeniden ölçeklendirerek algısal olarak sabit bir değişim hızı sağlamasıdır.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Sonsuz İnterpolatör", + "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite İnterpolatör", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Bu algoritma, algısal olarak daha homojen geçişler için YUV renk uzayında çalışarak renkleri sorunsuz bir şekilde interpole eder. Ana özelliği, her adımda parlaklık değişim hızını sınırlayarak ani ve rahatsız edici parlaklık parlamalarını önlemektir. Bu, animasyonu başlangıçta ayarlanan süresinin ötesine uzatarak akıcılığı korusa bile görsel olarak hoş bir etki sağlar.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Hibrit Fizik Sonsuz İnterpolatör (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite İnterpolatör: ataletli hibrit fizik (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Bu algoritma, hibrit bir fiziksel model kullanarak renkler arasında sorunsuz bir şekilde geçiş yapar. Doğrusal bir 'hızlandırıcı', hedef renge giden doğrudan yolu ve zamanlamayı tanımlarken, gerçek çıktı rengi sönümlü bir yaya bağlı bir nesne gibi bu hızı takip eder. Bu iki aşamalı yaklaşım, algısal olarak homojen YUV renk uzayında çalışırken, özelleştirilebilir atalet ve aşım değerleriyle akıcı, doğal görünümlü animasyonlar oluşturur.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hibrit Fizik Sonsuz İnterpolatör (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite İnterpolatör: ataletli hibrit fizik (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Bu algoritma, hibrit bir fiziksel model kullanarak renkler arasında sorunsuz geçişler sağlar. Doğrusal bir 'hız belirleyici', hedef renge giden doğrudan yolu ve zamanlamayı tanımlarken, gerçek çıktı rengi, sönümlü bir yaya bağlı bir nesne gibi bu hız belirleyiciyi takip eder. Bu iki parçalı yaklaşım, RGB renk uzayında çalışırken, özelleştirilebilir atalet ve aşırı sapma ile akıcı, doğal görünümlü animasyonlar oluşturur.", "edt_conf_enum_interpolator_smoothingFactor_title": "Yumuşatma Faktörü", "edt_conf_enum_interpolator_smoothingFactor_expl": "Bu parametre, animasyonun hissini belirler ve renkler arasında nasıl geçiş yapacağını kontrol eder. 0.0 ile 1.0 arasında bir değer kabul eder; 0.0 değeri doğrudan ve doğrusal bir değişime neden olur. Daha yüksek değerler daha fazla yumuşatma sağlar ve mevcut renk ideal konumun biraz gerisinde kaldığında akıcı bir 'kovalama' hareketi yaratır.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "RGB renk bileşenlerini doğrusal RGB uzayında belirli bir faktörle çarpar.", "edt_conf_processing_powerLimit_title": "Güç çıkışını sınırla", "edt_conf_processing_powerLimit_expl": "Bu özellik, mevcut sahne için toplam güç tüketiminin aşılıp aşılmadığını kontrol eder. Aşılırsa, her bir LED'in parlaklığını ve rengini otomatik olarak azaltır. Lütfen unutmayın, bu yeterince güçlü bir güç kaynağının yerine geçmez. Bu işlev yalnızca aşırı parlaklığı sınırlamak için tasarlanmıştır ve ekipmanınızı yetersiz güç kaynağı nedeniyle oluşabilecek hasarlardan korumaz. Bu özelliğin, LED kurulumunun gücünü belirli bir watt değerine doğrudan sınırlayacağını garanti etmiyoruz.", - "edt_conf_smoothing_testMode_expl": "Yumuşatma algoritmalarının test edilmesi için döngüsel ani renk değişimleri, konsola çıktı (Windows'ta HyperHDR'ı -c parametresiyle çalıştırın).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Üstel Sonsuz İnterpolatör", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Üstel Infinite İnterpolatör", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Yumuşatmanın klasik üssel uygulaması, LED renklerini bir hedefe doğru günceller, büyük farklılıklara hızlı tepki verir ve hedefe yaklaştıkça yavaşlar, böylece pürüzsüz ve doğal ortam aydınlatma geçişleri üretir.", "edt_dev_spec_macAddress_title": "MAC adresi", "wiz_lifx_error": "Lifx cihazları bulunamadı. HyperHDR kayıtlarını kontrol edin.", "wiz_lifx_title": "LIFX ışık sihirbazı", - "edt_dev_spec_convertToLinearRgb_title": "Lineer RGB’ye dönüştür" + "edt_dev_spec_convertToLinearRgb_title": "Lineer RGB’ye dönüştür", + "edt_conf_smooth_antiFlickeringFilter_title": "Titreme önleme filtresi", + "edt_conf_smooth_antiFlickeringFilter_expl": "24 bit RGB renk nicelemesinin neden olduğu hafif LED titremesini azaltan bir Infinite Color Engine filtresini etkinleştirir. Philips Hue (Eğlence modunda) veya LIFX cihazları gibi genişletilmiş renk formatlarını (derin renk) destekleyen denetleyicilerin bu filtreye hiç ihtiyacı yoktur." } diff --git a/www/i18n/vi.json b/www/i18n/vi.json index cac5085f7..1bad5a834 100644 --- a/www/i18n/vi.json +++ b/www/i18n/vi.json @@ -4,16 +4,16 @@ "InfoDialog_access_title": "Mức cài đặt", "InfoDialog_changePassword_success": "Mật khẩu đã được lưu thành công!", "InfoDialog_changePassword_title": "Đổi mật khẩu", - "InfoDialog_iswitch_text": "Nếu bạn chạy nhiều thực thể HyperHDR trong mạng nội bộ của mình, bạn có thể chuyền đổi giữa các cấu hình web. Hãy chọn thực thể HyperHDR bên dưới và chuyền đổi!", + "InfoDialog_iswitch_text": "Nếu bạn chạy nhiều thực thể HyperHDR trong mạng nội bộ của mình, bạn có thể chuyển đổi giữa các cấu hình web. Hãy chọn thực thể HyperHDR bên dưới và chuyển đổi!", "InfoDialog_iswitch_title": "Bộ chuyển đổi HyperHDR", "InfoDialog_lang_text": "Nếu bạn không thích kết quả phát hiện ngôn ngữ tự động, bạn có thể ghi đè nó ở đây.", "InfoDialog_lang_title": "Cài đặt ngôn ngữ", "InfoDialog_nowrite_foottext": "WebUI sẽ được mở khóa tự động sau khi bạn giải quyết vấn đề!", "InfoDialog_nowrite_text": "HyperHDR không thể ghi vào tệp cấu hình đã tải hiện tại của bạn. Vui lòng sửa các quyền đối với tệp để tiếp tục.", - "InfoDialog_nowrite_title": "lỗi quyền viết!", + "InfoDialog_nowrite_title": "Lỗi quyền ghi!", "about_3rd_party_licenses": "Giấy phép của bên thứ 3", "about_3rd_party_licenses_error": "Chúng tôi đã gặp sự cố khi thu thập thông tin giấy phép của bên thứ ba từ web.
Vui lòng theo liên kết này đến Tài nguyên GitHub.", - "about_build": "Xây dựng", + "about_build": "Nguồn xây dựng", "about_builddate": "Ngày xây dựng", "about_contribute": "Cùng chúng tôi phát triển HyperHDR hơn nữa!", "about_credits": "Tín dụng cho tất cả các nhà phát triển này!", @@ -56,8 +56,8 @@ "conf_leds_layout_checkp2": "Bố cục luôn là mặt trước của TV, không bao giờ là mặt sau.", "conf_leds_layout_checkp3": "Đảm bảo rằng hướng đi là đúng. Các đèn LED màu xám cho biết đèn LED số 2 và 3 để hiển thị hướng dữ liệu.", "conf_leds_layout_checkp4": "Khoảng cách trường hợp: Để tạo khoảng cách, trước tiên hãy bỏ qua nó khi bạn xác định Trên/Dưới/Trái/Phải và sau đó đặt độ dài khoảng cách của bạn để loại bỏ một lượng đèn led. Sửa đổi vị trí khoảng trống cho đến khi khớp.", - "conf_leds_layout_cl_bottom": "Đáy", - "conf_leds_layout_cl_bottomleft": "Góc dưới bên trái)", + "conf_leds_layout_cl_bottom": "Phía dưới", + "conf_leds_layout_cl_bottomleft": "Dưới cùng bên trái (Góc)", "conf_leds_layout_cl_bottomright": "Dưới cùng bên phải (Góc)", "conf_leds_layout_cl_cornergap": "Khoảng trống ở góc", "conf_leds_layout_cl_edgegap": "Khoảng cách cạnh", @@ -75,8 +75,8 @@ "conf_leds_layout_cl_rightbottom": "Bên phải: 50 - 100% từ Trên cùng", "conf_leds_layout_cl_rightmiddle": "Bên phải: 25 - 75% từ Trên cùng", "conf_leds_layout_cl_righttop": "Bên phải: 0 - 50% từ Trên cùng", - "conf_leds_layout_cl_top": "Hàng đầu", - "conf_leds_layout_cl_topleft": "Góc trên bên trái)", + "conf_leds_layout_cl_top": "Phía trên", + "conf_leds_layout_cl_topleft": "Trên cùng bên trái (Góc)", "conf_leds_layout_cl_topright": "Trên cùng bên phải (Góc)", "conf_leds_layout_cl_vleddepth": "Độ sâu LED dọc", "conf_leds_layout_frame": "Bố cục cổ điển (Khung LED)", @@ -257,17 +257,17 @@ "edt_conf_enum_bottom_up": "Từ dưới lên", "edt_conf_enum_brg": "BRG", "edt_conf_enum_color": "Màu sắc", - "edt_conf_enum_custom": "Phong tục", + "edt_conf_enum_custom": "Tùy chỉnh", "edt_conf_enum_decay": "Phân rã (không sử dụng nó)", "edt_conf_enum_dl_error": "Lỗi", "edt_conf_enum_dl_informational": "Thông tin", "edt_conf_enum_dl_nodebug": "Không có đầu ra Gỡ lỗi", "edt_conf_enum_dl_statechange": "Thay đổi trạng thái", - "edt_conf_enum_dl_verbose": "Dài dòng", - "edt_conf_enum_dl_verbose1": "Độ dài 1", - "edt_conf_enum_dl_verbose2": "Độ dài 2", - "edt_conf_enum_dl_verbose3": "Độ dài cấp độ 3", - "edt_conf_enum_effect": "Tác dụng", + "edt_conf_enum_dl_verbose": "Chi tiết", + "edt_conf_enum_dl_verbose1": "Mức chi tiết 1", + "edt_conf_enum_dl_verbose2": "Mức chi tiết 2", + "edt_conf_enum_dl_verbose3": "Mức chi tiết 3", + "edt_conf_enum_effect": "Hiệu ứng", "edt_conf_enum_gbr": "GBR", "edt_conf_enum_grb": "GRB", "edt_conf_enum_hsv": "HSV", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "Thiết bị thu âm thanh", "edt_conf_sound_device_expl": "Thiết bị thu âm hệ thống cho các plugin sử dụng trực quan hóa âm nhạc", "available_sound_devices": "Các thiết bị thu âm có sẵn", - "edt_conf_smooth_antiFlickeringTreshold_title": "Giá trị ngưỡng chống nhấp nháy", - "edt_conf_smooth_antiFlickeringTreshold_expl": "Trình phát video hoặc nội dung video nén giới thiệu một số phối màu ngẫu nhiên trong khi phát phim. Mặc dù những thay đổi về giá trị RGB có thể nhỏ nhưng chúng có thể gây ra hiệu ứng nhấp nháy trên hệ thống đèn nền của bạn trong những cảnh tối. Ví dụ: thay đổi một trong các giá trị RGB 1-3 từ phối màu có một hiệu ứng hình ảnh nhỏ trên các cảnh sáng nhưng trong điều kiện ánh sáng yếu thì nó khá ấn tượng. Bạn có thể bật hệ thống chống nhấp nháy cho chế độ ánh sáng yếu và đặt ngưỡng áp dụng bộ lọc để tránh trường hợp đó cho RGB dưới giá trị như vậy. Bộ lọc không chạm vào các đèn LED sáng có RGB trên ngưỡng như vậy. Hoạt động tốt nhất với đèn nền tối thiểu có màu trong tab xử lý.
Nếu bạn gặp phải hiện tượng nhấp nháy trên phim tĩnh/tạm dừng thì vấn đề của bạn có thể là do điện và tùy chọn đó sẽ không giúp ích gì. (0 = tùy chọn bị tắt, nếu không thì giá trị được đề xuất là 32)", - "edt_conf_smooth_antiFlickeringValue_title": "Bước tối thiểu chống nhấp nháy", - "edt_conf_smooth_antiFlickeringValue_expl": "Phải đạt được yêu cầu tối thiểu thay đổi kênh của màu (lời nhắc: dải RGB đầy đủ là 0-255 mỗi kênh) để ảnh hưởng đến nguồn LED. Mục tiêu đen RGB (0,0,0) bỏ qua điều đó để duy trì việc tắt đèn LED nếu đèn nền bị tắt", "main_ledsim_btn_screenshot": "Ảnh chụp màn hình", "edt_conf_enum_linear_alternative": "Tuyến tính thay thế (nhanh hơn)", - "edt_conf_smooth_antiFlickeringTimeout_title": "Thời gian chờ chống nhấp nháy", - "edt_conf_smooth_antiFlickeringTimeout_expl": "Cho phép thay đổi màu đèn LED RGB, sau thời gian tùy chỉnh tính bằng mili giây, ngay cả khi bước dưới mức tối thiểu (0 = bị vô hiệu hóa, nếu không giá trị được đề xuất ít nhất là 500 cho 0.5 giây)", "dashboard_current_video_device": "Thiết bị video", "dashboard_current_video_mode": "Chế độ quay", "general_comp_HDR": "HDR (toàn cầu)", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "Lạnh", "edt_conf_enum_neutral": "Trung tính", "edt_conf_enum_warm": "Ấm", - "edt_conf_enum_interpolator_Stepper_title": "Nội suy Tuyến tính", + "edt_conf_enum_interpolator_Stepper_title": "Bộ nội suy Infinite tuyến tính", "edt_conf_enum_interpolator_Stepper_expl": "Nội suy Tuyến tính là một phiên bản cải tiến của thuật toán cũ từ các phiên bản HyperHDR trước, được viết lại để sử dụng số học dấu phẩy động nhằm tăng độ chính xác. Thuật toán này hoạt động bằng cách nội suy tuyến tính màu hiện tại về phía màu mục tiêu, đảm bảo quá trình chuyển đổi hoàn tất trong một khoảng thời gian xác định bất kể tốc độ khung hình. Đặc điểm chính của nó là khả năng chuyển đổi mục tiêu giữa hoạt ảnh một cách mượt mà, bắt đầu một quá trình chuyển đổi mới, toàn thời gian từ trạng thái hiện tại sang mục tiêu mới.", - "edt_conf_enum_interpolator_RgbInterpolator_title": "Nội suy Vô hạn RGB", + "edt_conf_enum_interpolator_RgbInterpolator_title": "Bộ nội suy Infinite RGB", "edt_conf_enum_interpolator_RgbInterpolator_expl": "Thuật toán này hoạt động mượt mà các màu RGB trong một khoảng thời gian nhất định, cung cấp hai chế độ chuyển đổi riêng biệt. Chế độ đầu tiên là nội suy tuyến tính trực tiếp cho đường thẳng giữa các màu, trong khi chế độ thứ hai là chế độ làm mịn, trong đó màu hiện tại 'theo đuổi' mục tiêu một cách duyên dáng để tạo hiệu ứng ease-in/ease-out. Một tính năng chính là khả năng điều chỉnh lại thời lượng của hoạt ảnh một cách thông minh khi bị gián đoạn, đảm bảo tốc độ thay đổi không đổi về mặt cảm quan.", - "edt_conf_enum_interpolator_YuvInterpolator_title": "Bộ nội suy vô hạn YUV", + "edt_conf_enum_interpolator_YuvInterpolator_title": "Bộ nội suy Infinite YUV", "edt_conf_enum_interpolator_YuvInterpolator_expl": "Thuật toán này nội suy màu sắc một cách mượt mà bằng cách hoạt động trong không gian màu YUV để có các chuyển tiếp đồng đều hơn về mặt cảm quan. Tính năng chính của nó là hạn chế tốc độ thay đổi độ sáng ở mỗi bước, ngăn ngừa các tia sáng đột ngột, chói mắt. Điều này đảm bảo hiệu ứng thị giác dễ chịu, ngay cả khi nó kéo dài hoạt ảnh vượt quá thời lượng ban đầu để duy trì độ mượt mà đó.", - "edt_conf_enum_interpolator_HybridInterpolator_title": "Bộ nội suy vô hạn Vật lý lai (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Bộ nội suy Infinite: vật lý lai có quán tính (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "Thuật toán này chuyển đổi mượt mà giữa các màu sắc bằng cách sử dụng mô hình vật lý lai. Một 'bộ điều chỉnh' tuyến tính xác định đường dẫn trực tiếp và thời gian đến màu mục tiêu, trong khi màu đầu ra thực tế tuân theo pacer này giống như một vật thể được gắn vào một lò xo bị giảm chấn. Phương pháp hai phần này tạo ra các hoạt ảnh mượt mà, tự nhiên với quán tính và độ vượt mức có thể tùy chỉnh, tất cả trong khi hoạt động trong không gian màu YUV đồng nhất về mặt cảm quan.", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Bộ nội suy vô hạn Vật lý lai (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Bộ nội suy Infinite: vật lý lai có quán tính (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "Thuật toán này chuyển đổi màu sắc một cách mượt mà bằng cách sử dụng mô hình vật lý lai. Một 'bộ điều chỉnh' tuyến tính xác định đường dẫn trực tiếp và thời gian đến màu mục tiêu, trong khi màu đầu ra thực tế sẽ theo bộ điều chỉnh này giống như một vật thể gắn vào một lò xo giảm chấn. Cách tiếp cận hai phần này tạo ra các hoạt ảnh mượt mà, tự nhiên với quán tính và độ vượt mức có thể tùy chỉnh, tất cả đều hoạt động trong không gian màu RGB.", "edt_conf_enum_interpolator_smoothingFactor_title": "Hệ số làm mịn", "edt_conf_enum_interpolator_smoothingFactor_expl": "Tham số này quyết định cảm giác của hoạt ảnh, kiểm soát cách chuyển đổi giữa các màu. Nó chấp nhận giá trị từ 0.0 đến 1.0, trong đó 0.0 dẫn đến sự thay đổi tuyến tính trực tiếp. Giá trị cao hơn tạo ra hiệu ứng làm mịn hơn, tạo ra chuyển động 'đuổi' mượt mà khi màu hiện tại chậm hơn một chút so với vị trí lý tưởng.", @@ -1292,7 +1286,7 @@ "edt_conf_enum_interpolator_y_limit_expl": "Tham số này đặt giới hạn tuyệt đối về mức độ sáng (kênh Y trong YUV) có thể thay đổi trong một bước cập nhật duy nhất. Nó hoạt động như một giới hạn cứng có thể ghi đè lên vật lý của lò xo, ngăn chặn các hiệu ứng nhấp nháy hoặc nhấp nháy gây khó chịu trong quá trình chuyển đổi nhanh giữa các màu rất tối và rất sáng. Đặt giá trị này thành một giá trị dương nhỏ đảm bảo độ sáng tăng dần rất mượt mà, trong khi đặt giá trị về 0 sẽ vô hiệu hóa hoàn toàn giới hạn này.", "edt_conf_color_backlightThreshold_title": "Mức đèn nền tối thiểu", "edt_conf_color_backlightThreshold_expl": "Mức độ sáng tối thiểu (thang đo 0-1.0). Mỗi bước 0.0039(2) tương ứng với 1 trong thang đo 0-255. Tắt trong hiệu ứng, màu sắc và ở trạng thái \"Tắt\".", - "edt_conf_color_channelAdjustment_header_title": "Công cụ Màu Vô hạn", + "edt_conf_color_channelAdjustment_header_title": "Infinite Color Engine", "edt_conf_color_channelAdjustment_header_expl": "Tạo các cấu hình màu có thể được gán cho một thành phần cụ thể. Điều chỉnh màu sắc, gamma, độ sáng, độ bão hòa và nhiều hơn nữa. Các phép tính độ chính xác cao (float) được sử dụng để xử lý màu.", "edt_conf_color_classic_config_title": "Hiệu chuẩn RGB", "edt_conf_color_classic_config_expl": "Hiệu chuẩn bằng ba màu cơ bản (đỏ, lục, lam). Đủ cho hầu hết các trường hợp.", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "Nhân các thành phần màu RGB với một hệ số nhất định trong không gian RGB tuyến tính.", "edt_conf_processing_powerLimit_title": "Giới hạn công suất đầu ra", "edt_conf_processing_powerLimit_expl": "Tính năng này kiểm tra xem tổng công suất tiêu thụ của cảnh hiện tại có bị vượt quá hay không. Nếu có, tính năng này sẽ tự động giảm độ sáng và màu sắc của từng đèn LED. Xin lưu ý, tính năng này không thay thế cho bộ nguồn đủ mạnh. Chức năng này chỉ được thiết kế để hạn chế độ sáng quá mức và sẽ không bảo vệ thiết bị của bạn khỏi hư hỏng do bộ nguồn quá nhỏ. Chúng tôi không đảm bảo rằng tính năng này sẽ trực tiếp chuyển thành việc giới hạn công suất của thiết lập đèn LED ở một giá trị công suất cụ thể.", - "edt_conf_smoothing_testMode_expl": "Thay đổi màu đột ngột theo chu kỳ để kiểm tra thuật toán làm mịn, xuất ra bảng điều khiển (trên Windows, hãy chạy HyperHDR với tham số -c).", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Bộ nội suy vô hạn theo hàm mũ", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Bộ nội suy Infinite hàm mũ", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Việc triển khai làm mịn theo hàm mũ cổ điển sẽ cập nhật màu sắc đèn LED hướng đến mục tiêu, phản ứng nhanh với những khác biệt lớn và chậm lại khi chúng tiến gần đến mục tiêu, tạo ra hiệu ứng chuyển tiếp ánh sáng xung quanh mượt mà, tự nhiên.", "edt_dev_spec_macAddress_title": "Địa chỉ MAC", "wiz_lifx_error": "Không tìm thấy thiết bị Lifx. Hãy kiểm tra nhật ký HyperHDR.", "wiz_lifx_title": "Trình hướng dẫn đèn LIFX", - "edt_dev_spec_convertToLinearRgb_title": "Chuyển đổi sang RGB tuyến tính" + "edt_dev_spec_convertToLinearRgb_title": "Chuyển đổi sang RGB tuyến tính", + "edt_conf_smooth_antiFlickeringFilter_title": "Bộ lọc chống nhấp nháy", + "edt_conf_smooth_antiFlickeringFilter_expl": "Kích hoạt bộ lọc Infinite Color Engine giúp giảm hiện tượng nhấp nháy đèn LED tinh vi do lượng tử hóa màu RGB 24-bit gây ra. Các bộ điều khiển hỗ trợ định dạng màu mở rộng (deep color), chẳng hạn như Philips Hue (ở chế độ Giải trí) hoặc thiết bị LIFX, hoàn toàn không cần bộ lọc này." } diff --git a/www/i18n/zh-CN.json b/www/i18n/zh-CN.json index 1711ba481..cda5eee69 100644 --- a/www/i18n/zh-CN.json +++ b/www/i18n/zh-CN.json @@ -13,11 +13,11 @@ "InfoDialog_nowrite_title": "写权限错误！", "about_3rd_party_licenses": "第三方许可证", "about_3rd_party_licenses_error": "我们无法从网络收集 3rd 方许可信息。
请通过此链接访问 GitHub 资源。", - "about_build": "建造", - "about_builddate": "建造日期", + "about_build": "构建源代码", + "about_builddate": "构建日期", "about_contribute": "与我们一起进一步开发 HyperHDR！", "about_credits": "感谢所有这些开发人员！", - "about_resources": "$1 图书馆", + "about_resources": "$1 库", "about_translations": "翻译", "about_version": "版本", "conf_colors_blackborder_intro": "跳过黑条，无论它们在哪里。每种模式都使用另一种针对特殊情况进行调整的检测算法。如果它不适合您，请提高阈值。", @@ -27,8 +27,8 @@ "conf_effect_fgeff_intro": "定义启动效果或颜色，在 HyperHDR 启动期间显示定义的持续时间。", "conf_effect_path_intro": "从定义的路径加载效果。此外，您可以按名称禁用单个效果以将它们从所有效果列表中隐藏。", "conf_general_createInst_btn": "创建实例", - "conf_general_impexp_expbtn": "出口", - "conf_general_impexp_impbtn": "进口", + "conf_general_impexp_expbtn": "导出", + "conf_general_impexp_impbtn": "导入", "conf_general_impexp_l1": "导入/导出所有 HyperHDR 实例的配置备份。不会保存用户访问密码，但实例的设置中可能包含一些敏感数据（例如：“Philips Hue”访问密钥）。", "conf_general_impexp_l2": "备份文件格式与 HyperHDR v17 及更高版本兼容。", "conf_general_impexp_title": "导入/导出配置", @@ -57,8 +57,8 @@ "conf_leds_layout_checkp3": "确保方向正确。灰色 LED 指示 LED 编号 2 和 3，以显示数据方向。", "conf_leds_layout_checkp4": "Case Gap：要创建一个间隙，请在定义 Top/Bottom/Left/Right 时首先忽略它，然后设置间隙长度以移除一定数量的 LED。修改间隙位置，直到匹配为止。", "conf_leds_layout_cl_bottom": "底部", - "conf_leds_layout_cl_bottomleft": "左下角（角落）", - "conf_leds_layout_cl_bottomright": "右下角（角落）", + "conf_leds_layout_cl_bottomleft": "左下 (角)", + "conf_leds_layout_cl_bottomright": "右下 (角)", "conf_leds_layout_cl_cornergap": "角间隙", "conf_leds_layout_cl_edgegap": "边缘间隙", "conf_leds_layout_cl_gaglength": "间隙长度", @@ -75,9 +75,9 @@ "conf_leds_layout_cl_rightbottom": "右：50 - 100% 从顶部", "conf_leds_layout_cl_rightmiddle": "右：25 - 75% 从顶部", "conf_leds_layout_cl_righttop": "右：0 - 50% 从顶部", - "conf_leds_layout_cl_top": "最佳", - "conf_leds_layout_cl_topleft": "左上角（角落）", - "conf_leds_layout_cl_topright": "右上角（角落）", + "conf_leds_layout_cl_top": "顶部", + "conf_leds_layout_cl_topleft": "左上 (角)", + "conf_leds_layout_cl_topright": "右上 (角)", "conf_leds_layout_cl_vleddepth": "垂直 LED 深度", "conf_leds_layout_frame": "经典布局（LED 框架）", "conf_leds_layout_generatedconf": "生成/当前 LED 配置", @@ -257,7 +257,7 @@ "edt_conf_enum_bottom_up": "自下而上", "edt_conf_enum_brg": "BRG", "edt_conf_enum_color": "颜色", - "edt_conf_enum_custom": "风俗", + "edt_conf_enum_custom": "自定义", "edt_conf_enum_decay": "衰减（不要使用）", "edt_conf_enum_dl_error": "错误", "edt_conf_enum_dl_informational": "信息性", @@ -267,7 +267,7 @@ "edt_conf_enum_dl_verbose1": "详细级别 1", "edt_conf_enum_dl_verbose2": "详细级别 2", "edt_conf_enum_dl_verbose3": "详细级别 3", - "edt_conf_enum_effect": "影响", + "edt_conf_enum_effect": "效果", "edt_conf_enum_gbr": "英国广播公司", "edt_conf_enum_grb": "伽玛暴", "edt_conf_enum_hsv": "HSV", @@ -980,14 +980,8 @@ "edt_conf_sound_device_title": "声音捕捉装置", "edt_conf_sound_device_expl": "使用音乐可视化的插件系统声音捕获设备", "available_sound_devices": "可用的声音捕捉设备", - "edt_conf_smooth_antiFlickeringTreshold_title": "抗闪烁阈值", - "edt_conf_smooth_antiFlickeringTreshold_expl": "视频播放器或压缩视频内容在播放电影时会引入一些随机抖动。尽管 RGB 值的变化可能很小，但它们可能会在黑暗场景中对环境光系统造成闪烁效果。例如，通过抖动将 RGB 值之一更改为 1-3 对明亮场景的视觉效果很小，但在低光下则非常引人注目。您可以为低光模式启用抗闪烁系统并设置阈值以应用过滤器以避免 RGB 低于此值的情况。 RGB 高于此阈值的明亮 LED 不会被过滤器触及。在处理选项卡中使用彩色最小背光效果最佳。
如果您在静态/暂停的电影中遇到闪烁，那么您的问题可能具有电气性质，该选项将无济于事。（0 = 该选项已禁用，否则建议值是 32)", - "edt_conf_smooth_antiFlickeringValue_title": "防闪烁最小步长", - "edt_conf_smooth_antiFlickeringValue_expl": "必须达到的最小颜色通道更改（提醒：完整的 RGB 范围为 0-255）以影响 LED 光源。如果背光被禁用，RGB 黑色目标 (0,0,0) 会忽略它以保持关闭 LED", "main_ledsim_btn_screenshot": "截屏", "edt_conf_enum_linear_alternative": "替代线性（更快）", - "edt_conf_smooth_antiFlickeringTimeout_title": "防闪烁超时", - "edt_conf_smooth_antiFlickeringTimeout_expl": "允许在自定义时间（以毫秒为单位）之后更改 RGB LED 颜色，即使步长低于最小值（0 = 禁用，否则建议值至少为 500，即提供 0.5 秒）", "dashboard_current_video_device": "视频设备", "dashboard_current_video_mode": "视频模式", "general_comp_HDR": "HDR（全球）", @@ -1272,15 +1266,15 @@ "edt_conf_enum_cold": "冷色", "edt_conf_enum_neutral": "中性色", "edt_conf_enum_warm": "暖色", - "edt_conf_enum_interpolator_Stepper_title": "线性插值器", + "edt_conf_enum_interpolator_Stepper_title": "线性 Infinite 内插器", "edt_conf_enum_interpolator_Stepper_expl": "线性插值器改编自 HyperHDR 先前版本的遗留算法，并重新编写为使用浮点运算以提高精度。它通过线性插值当前颜色到目标颜色来工作，确保过渡在定义的时长内完成，不受帧速率影响。其主要特性是能够在动画中途平滑地重新定位，从当前状态启动一个新的、完整的时长过渡到新的目标状态。", - "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB 无限插值器", + "edt_conf_enum_interpolator_RgbInterpolator_title": "RGB Infinite 内插器", "edt_conf_enum_interpolator_RgbInterpolator_expl": "该算法在设定的时长内平滑地对 RGB 颜色进行动画处理，并提供两种不同的过渡模式。第一种是直接线性插值，用于颜色之间的直线路径；第二种是平滑模式，当前颜色优雅地“追逐”目标颜色，以创建缓入/缓出效果。其关键特性是能够在动画中断时智能地调整动画时长，确保变化速度在感知上保持恒定。", - "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV 无限插值器", + "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite 内插器", "edt_conf_enum_interpolator_YuvInterpolator_expl": "该算法通过在 YUV 颜色空间中操作来平滑地插值颜色，以实现更感知均匀的过渡。其主要特点是限制每一步的亮度变化率，防止出现突兀刺眼的亮光闪烁。这确保了令人愉悦的视觉效果，即使动画超出其初始设定的时长也能保持这种平滑度。", - "edt_conf_enum_interpolator_HybridInterpolator_title": "混合物理无限插值器 (YUV)", + "edt_conf_enum_interpolator_HybridInterpolator_title": "Infinite 内插器：带惯性的混合物理 (YUV)", "edt_conf_enum_interpolator_HybridInterpolator_expl": "该算法使用混合物理模型在颜色之间平滑过渡。线性“步进器”定义了到达目标颜色的直接路径和时间，而实际输出颜色则像连接到阻尼弹簧的物体一样跟随该步进器。这种由两部分组成的方法可以创建流畅自然的动画，并具有可自定义的惯性和过冲，所有这些都在感知均匀的 YUV 颜色空间中操作。", - "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "混合物理无限插值器 (RGB)", + "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Infinite 内插器：带惯性的混合物理 (RGB)", "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "该算法采用混合物理模型，实现颜色间的平滑过渡。线性“步进器”定义了到达目标颜色的直接路径和时间，而实际输出颜色则像连接在阻尼弹簧上的物体一样跟随该步进器运动。这种两步式方法能够创建流畅自然的动画，并可自定义惯性和过冲，所有操作均在 RGB 色彩空间中进行。", "edt_conf_enum_interpolator_smoothingFactor_title": "平滑系数", "edt_conf_enum_interpolator_smoothingFactor_expl": "该参数决定了动画的感觉，控制其在颜色之间的过渡方式。它接受从 0.0 到 1.0 的值，其中 0.0 表示直接的线性变化。值越高，平滑度越高，当当前颜色略微滞后于理想位置时，会产生流畅的“追逐”运动。", @@ -1292,7 +1286,7 @@ "edt_conf_enum_interpolator_y_limit_expl": "此参数设置了亮度（YUV 中的 Y 通道）在单个更新步骤中可以变化的绝对上限。它充当一个可以覆盖弹簧物理特性的硬性限制，防止在非常暗和非常亮的颜色之间快速过渡时出现刺眼的闪烁或频闪效果。将其设置为较小的正值可确保非常平滑的亮度变化，而将其设置为零则完全禁用该限制。", "edt_conf_color_backlightThreshold_title": "最低背光等级", "edt_conf_color_backlightThreshold_expl": "最低亮度等级（0-1.0 级）。每 0.0039(2) 级对应于 0-255 级中的 1。在特效、色彩和“关闭”状态下禁用。", - "edt_conf_color_channelAdjustment_header_title": "无限色彩引擎", + "edt_conf_color_channelAdjustment_header_title": "Infinite Color Engine", "edt_conf_color_channelAdjustment_header_expl": "创建可分配给特定成分的色彩配置文件。调整色彩、伽玛、亮度、饱和度等。使用高精度（浮点）计算进行色彩处理。", "edt_conf_color_classic_config_title": "RGB 校准", "edt_conf_color_classic_config_expl": "使用三原色（红、绿、蓝）进行校准。在大多数情况下足够。", @@ -1302,11 +1296,12 @@ "edt_conf_processing_scaleOutput_expl": "将 RGB 颜色分量乘以线性 RGB 空间中的给定因子。", "edt_conf_processing_powerLimit_title": "限制功率输出", "edt_conf_processing_powerLimit_expl": "此功能会检查当前场景的总功耗是否已超出。如果超出，则会自动降低每个 LED 的亮度和颜色。请注意，这不能替代足够强大的电源。此功能仅用于限制过高的亮度，并不能保护您的设备免受电源功率不足造成的损坏。我们不保证此功能会直接转化为将 LED 设备的功率限制在特定瓦数值。", - "edt_conf_smoothing_testMode_expl": "用于平滑算法测试的周期性颜色突变，输出到控制台（在 Windows 上，请使用 -c 参数运行 HyperHDR）。", - "edt_conf_enum_interpolator_ExponentialInterpolator_title": "指数无限插值器", + "edt_conf_enum_interpolator_ExponentialInterpolator_title": "指数 Infinite 内插器", "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "经典的指数平滑实现，使 LED 色彩向目标值靠拢，对较大的差异做出快速反应，并在接近目标值时减慢速度，从而产生平滑、自然的环境光过渡。", "edt_dev_spec_macAddress_title": "MAC 地址", "wiz_lifx_error": "找不到 Lifx 设备。请检查 HyperHDR 日志。", "wiz_lifx_title": "LIFX 灯光向导", - "edt_dev_spec_convertToLinearRgb_title": "转换为线性 RGB" + "edt_dev_spec_convertToLinearRgb_title": "转换为线性 RGB", + "edt_conf_smooth_antiFlickeringFilter_title": "抗闪烁过滤器", + "edt_conf_smooth_antiFlickeringFilter_expl": "启用 Infinite Color Engine 过滤器，减少由 24 位 RGB 颜色量化引起的细微 LED 闪烁。支持扩展颜色格式（深色）的控制器，如 Philips Hue（在娱乐模式下）或 LIFX 设备，完全不需要此过滤器。" }