BlackBorderProcessor.h

#pragma once

// QT includes
#include <QJsonObject>

// util
#include <utils/Logger.h>
#include <utils/settings.h>
#include <utils/Components.h>

// Local Hyperion includes
#include "BlackBorderDetector.h"

class Hyperion;

namespace hyperion
{
    class BlackBorderProcessor : public QObject
    {
        Q_OBJECT
    public:
        BlackBorderProcessor(Hyperion* hyperion, QObject* parent);
        ~BlackBorderProcessor();
        BlackBorder getCurrentBorder() const;

        bool enabled() const;

        void setEnabled(bool enable);

        void setHardDisable(const bool& disable);

        template <typename Pixel_T>
        bool process(const Image<Pixel_T> & image)
        {
            // get the border for the single image
            BlackBorder imageBorder;
            if (!enabled())
            {
                imageBorder.horizontalSize = 0;
                imageBorder.verticalSize = 0;
                imageBorder.unknown=true;
                _currentBorder = imageBorder;
                return true;
            }

            if (_detectionMode == "default") {
                imageBorder = _detector->process(image);
            } else if (_detectionMode == "classic") {
                imageBorder = _detector->process_classic(image);
            } else if (_detectionMode == "osd") {
                imageBorder = _detector->process_osd(image);
            }
            // add blur to the border
            if (imageBorder.horizontalSize > 0)
            {
                imageBorder.horizontalSize += _blurRemoveCnt;
            }
            if (imageBorder.verticalSize > 0)
            {
                imageBorder.verticalSize += _blurRemoveCnt;
            }

            const bool borderUpdated = updateBorder(imageBorder);
            return borderUpdated;
        }
    private slots:
        void handleSettingsUpdate(const settings::type& type, const QJsonDocument& config);

        void componentStateChanged(const hyperion::Components component, bool enable);

    private:
        Hyperion* _hyperion;

        bool updateBorder(const BlackBorder & newDetectedBorder);

        bool _enabled;

        unsigned _unknownSwitchCnt;

        unsigned _borderSwitchCnt;

        // The number of frames that are "ignored" before a new border gets set as _previousDetectedBorder
        unsigned _maxInconsistentCnt;

        unsigned _blurRemoveCnt;

        QString _detectionMode;

        BlackBorderDetector* _detector;

        BlackBorder _currentBorder;

        BlackBorder _previousDetectedBorder;

        unsigned _consistentCnt;
        unsigned _inconsistentCnt;
        double _oldThreshold;
        bool _hardDisabled;
        bool _userEnabled;

    };
} // end namespace hyperion