Fix rendering w/o continuous output

Author: awawa-dev

include/infinite-color-engine/InfiniteSmoothing.h

@@ -91,4 +91,5 @@ private slots:
 	bool			_infoUpdate;
 	bool			_infoInput;
 	int				_coolDown;
+	long long		_lastSentFrame;
 };

sources/base/schema/schema-smoothing.json

@@ -123,18 +123,9 @@
 			"type" : "boolean",
 			"format": "checkbox",
 			"title" : "edt_conf_smooth_continuousOutput_title",
-			"default" : false,
+			"default" : true,
 			"required" : true,
 			"propertyOrder" : 10
-		},
-		"testMode" :
-		{
-			"type" : "boolean",
-			"format": "checkbox",
-			"title" : "edt_conf_smoothing_testMode_title",
-			"default" : false,
-			"required" : true,
-			"propertyOrder" : 11
 		}
 	},
 	"additionalProperties" : false

sources/infinite-color-engine/InfiniteSmoothing.cpp

@@ -61,57 +61,6 @@ namespace
 	constexpr int64_t  DEFAUL_SETTLINGTIME = 200;   // settlingtime in ms
 	constexpr double   DEFAUL_UPDATEFREQUENCY = 25;    // updatefrequncy in hz
 	constexpr double   MINIMAL_UPDATEFREQUENCY = 20;
-
-	struct TestPilot
-	{
-		bool active = false;
-		long long started = 0;
-		std::vector<float4> sequence = {
-			{0,    0.0f, 0.0f, 0.0f},  // start from black color
-			{2000, 1.0f, 0.0f, 0.0f},  // short (100ms) red color blink at 2.0sec
-			{2100, 0.0f, 0.0f, 0.0f},  // return to black color
-			{2300, 0.0f, 1.0f, 0.0f},  // short (100ms) green color blink at 2.3sec
-			{2400, 0.0f, 0.0f, 0.0f},  // return to black color
-			{2600, 0.0f, 0.0f, 1.0f},  // short (100ms) blue color blink at 2.6sec
-			{2700, 0.0f, 0.0f, 0.0f},  // return to black color
-			{3000, 0.0f, 0.0f, 1.0f},  // start moving to blue color at 3sec
-			{3200, 0.0f, 1.0f, 0.0f},  // then turn to green color at 3.2sec
-			{3400, 1.0f, 0.0f, 0.0f},  // then immediately turn to red color at 3.4sec and wait
-			{4000, 0.0f, 0.0f, 1.0f},  // start moving to blue color at 4sec
-			{4100, 1.0f, 0.0f, 0.0f},  // then turn to red color at 4.1sec
-			{4200, 0.0f, 1.0f, 0.0f},  // the turn to green at 4.2sec and wait 
-			{6000, 0.0f, 0.0f, 0.0f},  // finally return to black color at 6sec
-			{8000, 0.0f, 0.0f, 0.0f}   // the end of the cycle at 6sec
-		};
-		float3 getColorAtTime(long long currentTimeMs)
-		{
-			long long delta = currentTimeMs - started;
-
-			if (!sequence.empty() && delta > static_cast<long long>(sequence.back().x)) {
-				started = currentTimeMs;
-				delta = 0;
-			}
-
-			float3 color = { 0.0f, 0.0f, 0.0f };
-
-			for (size_t i = 1; i < sequence.size(); ++i) {
-				if (delta < static_cast<long long>(sequence[i].x)) {
-					color = { sequence[i - 1].y, sequence[i - 1].z, sequence[i - 1].w };
-					break;
-				}
-			}
-
-			printf("Δ%4lld | incomingColors: (%d, %d, %d)", delta, (int)(color.x * 255), (int)(color.y * 255), (int)(color.z * 255));
-
-			return color;
-		}
-	};
-
-	TestPilot& getTestPilot()
-	{
-		static TestPilot testPilot;
-		return testPilot;
-	}
 }
 
 InfiniteSmoothing::InfiniteSmoothing(const QJsonDocument& config, HyperHdrInstance* hyperhdr)
@@ -125,7 +74,8 @@ InfiniteSmoothing::InfiniteSmoothing(const QJsonDocument& config, HyperHdrInstan
 	_interpolator(std::make_unique<InfiniteStepperInterpolator>()),
 	_infoUpdate(true),
 	_infoInput(true),
-	_coolDown(0)
+	_coolDown(SMOOTHING_COOLDOWN_PHASE),
+	_lastSentFrame(0)
 {
 	// init cfg 0 (SMOOTHING_USER_CONFIG)
 	addConfig(DEFAUL_SETTLINGTIME, DEFAUL_UPDATEFREQUENCY);
@@ -152,7 +102,8 @@ void InfiniteSmoothing::clearQueuedColors(bool deviceEnabled, bool restarting)
 
 		_infoUpdate = true;
 		_infoInput = true;
-		_coolDown = 0;
+		_coolDown = (deviceEnabled) ? SMOOTHING_COOLDOWN_PHASE: 0;
+		_lastSentFrame = 0;
 
 		if (restarting || _interpolator == nullptr)
 		{
@@ -219,11 +170,6 @@ void InfiniteSmoothing::handleSignalInstanceSettingsChanged(settings::type type,
 
 		_continuousOutput = obj["continuousOutput"].toBool(true);
 
-		if (getTestPilot().active = obj["testMode"].toBool(false); getTestPilot().active)
-		{
-			getTestPilot().started = InternalClock::now();
-		}
-
 		_configurations[SMOOTHING_USER_CONFIG] = std::make_unique<SmoothingConfig>(
 			SmoothingConfig{
 			.pause = false,
@@ -276,39 +222,42 @@ void InfiniteSmoothing::incomingColors(std::vector<float3>&& nonlinearRgbColors)
 		QMutexLocker locker(&_dataSynchro);
 
 		auto nowTime = InternalClock::now();
-		if (getTestPilot().active)
-		{
-			std::fill(nonlinearRgbColors.begin(), nonlinearRgbColors.end(), getTestPilot().getColorAtTime(nowTime));
-		}
-		_interpolator->setTargetColors(std::move(nonlinearRgbColors), nowTime, getTestPilot().active);
+		_interpolator->setTargetColors(std::move(nonlinearRgbColors), nowTime, false);
 	}
 }
 
 void InfiniteSmoothing::updateLeds()
 {	
 	SharedOutputColors nonlinearRgbColors;
 	bool finished = false;
+	long long timeNow = 0;
 	// critical section
 	{
 		QMutexLocker locker(&_dataSynchro);
 		if (!isEnabled())
 			return;
-		_interpolator->updateCurrentColors(InternalClock::now());
+
+		timeNow = InternalClock::now();
+		_interpolator->updateCurrentColors(timeNow);
 
 		nonlinearRgbColors = _interpolator->getCurrentColors();
 
 		if (!_interpolator->isAnimationComplete())
 		{
 			_coolDown = SMOOTHING_COOLDOWN_PHASE;
 		}
-		else
+		else if (!_continuousOutput)
 		{
-			finished = (!_continuousOutput) && (_coolDown <= 0 || _coolDown-- <= 0);
+			if (_coolDown > 0)
+				_coolDown--;
+			else if (std::abs(timeNow - _lastSentFrame) < 1000)
+				finished = true;
 		}
 	}	
 
 	if (!nonlinearRgbColors->empty() && !finished)
 	{
+		_lastSentFrame = timeNow;
 		queueColors(std::move(nonlinearRgbColors));
 	}
 }
@@ -318,13 +267,6 @@ void InfiniteSmoothing::queueColors(SharedOutputColors&& nonlinearRgbLedColors)
 	if (nonlinearRgbLedColors->empty())
 		return;
 
-	if (getTestPilot().active)
-	{
-		const auto& color = nonlinearRgbLedColors->front();
-		long long delta = InternalClock::now() - getTestPilot().started;
-		printf("Δ%4lld | updateCurrentColors: (%d, %d, %d)\n", delta, (int)(color.x * 255), (int)(color.y * 255), (int)(color.z * 255));
-	}
-
 	emit SignalProcessedColors(nonlinearRgbLedColors);
 }
 

www/i18n/cs.json

@@ -1300,7 +1300,6 @@
   "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. <strong>Upozorňujeme, že se nejedná o náhradu dostatečně výkonného zdroje napájení.</strong> 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_title": "Testovací režim",
   "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_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.",

www/i18n/de.json

@@ -1300,7 +1300,6 @@
   "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. <strong>Bitte beachten Sie: Dies ist kein Ersatz für ein ausreichend leistungsstarkes Netzteil.</strong> 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_title": "Testmodus",
   "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_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.",

www/i18n/en.json

@@ -1300,7 +1300,6 @@
   "edt_conf_processing_scaleOutput_expl": "Multiplies the RGB color components by a given factor in the linear RGB space.",
   "edt_conf_processing_powerLimit_title": "Limit power output",
   "edt_conf_processing_powerLimit_expl": "This feature checks whether the total power draw for the current scene has been exceeded. If so, it automatically scales down the brightness and color of each LED. <strong>Please note, this is not a substitute for a sufficiently powerful power supply.</strong> This function is only designed to limit excessive brightness and will not protect your equipment from damage due to an undersized power supply. We do not guarantee that this feature will directly translate into limiting the power of the LED setup to a specific wattage value.",
-  "edt_conf_smoothing_testMode_title": "Test mode",
   "edt_conf_smoothing_testMode_expl": "Cyclic sudden color changes for smoothing algorithms testing, output to the console (on Windows run HyperHDR with -c parameter).",
   "edt_conf_enum_interpolator_ExponentialInterpolator_title": "Exponential Infinite Interpolator",
   "edt_conf_enum_interpolator_ExponentialInterpolator_expl": "Classic exponential implementation of smoothing updates LED colors toward a target, reacting quickly to large differences and slowing as they approach the target, producing smooth, natural ambient lighting transitions.",

www/i18n/es.json

@@ -1300,7 +1300,6 @@
   "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_title": "Modo de prueba",
   "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_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.",

www/i18n/fr.json

@@ -1300,7 +1300,6 @@
   "edt_conf_processing_scaleOutput_expl": "Multiplie les composantes de couleur RVB par un facteur donné dans l'espace RVB 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. <strong>Veuillez noter que cela ne remplace pas une alimentation suffisamment puissante.</strong> 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_title": "Mode test",
   "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_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.",

www/i18n/it.json

@@ -1300,7 +1300,6 @@
   "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. <strong>Nota: questa funzione non sostituisce un alimentatore sufficientemente potente.</strong> 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_title": "Modalità test",
   "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_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.",

www/i18n/nl.json

@@ -1300,7 +1300,6 @@
   "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. <strong>Let op: dit is geen vervanging voor een voldoende krachtige voeding.</strong> 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_title": "Testmodus",
   "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_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.",