builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/javascriptfiltersdk/src/reader.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#pragma once
#include <adtfstreaming3/samplereader.h>
#include <adtfmediadescription/sample_codec.h>
#include <adtfstreaming3/streammetatypeimage.h>
 
#include <QJsonObject>
#include <QImage>
#include <QJSEngine>
 
#include <unordered_map>
#include <mutex>
#include <string>
 
using namespace adtf::ucom;
using namespace adtf::util;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::mediadescription;
 
namespace adtf
{
 
namespace javascript
{
 
namespace scripting
{
 
struct tConversionFormat
{
    QImage::Format eDestinationFormat;
    bool bRequiresInvert;
    QImage::InvertMode eInvertMode;
};
 
class cImageConverter
{
    public:
        cImageConverter(const IStreamType& oType);
        QImage convert(const ISample& oSample);
 
    private:
        tStreamImageFormat m_sInputFormat;
        tConversionFormat m_sOutputFormat;
};
 
inline tResult script_error_to_result(const QJSValue& oScriptResult)
{
    if (oScriptResult.isError())
    {
        RETURN_ERROR_DESC(ERR_FAILED, "Uncaught script exception at %s:%u: %s",
                          oScriptResult.property("fileName").toString().toLocal8Bit().data(),
                          oScriptResult.property("lineNumber").toInt(),
                          oScriptResult.toString().toLocal8Bit().data());
    }
    else
    {
        RETURN_ERROR_DESC(ERR_FAILED, "Uncaught script exception: %s",
                          oScriptResult.toString().toLocal8Bit().data());
    }
}
 
class cSyncSignalRecievers: public QObject
{
    Q_OBJECT
 
    public:
        Q_INVOKABLE void connect(QJSValue oReciever)
        {
            m_oRecievers.push_back(oReciever);
        }
 
        template <typename ...Arguments>
        tResult call(Arguments&& ... arguments)
        {
            QJSValueList oJSArgs{std::forward<Arguments>(arguments)...};
            for (auto& oReciever: m_oRecievers)
            {
                auto oScriptResult = oReciever.call(oJSArgs);
                if (!oScriptResult.isNull() && !oScriptResult.isUndefined())
                {
                    return script_error_to_result(oScriptResult);
                }
            }
 
            RETURN_NOERROR;
        }
 
        bool isConnected() const
        {
            return !m_oRecievers.empty();
        }
 
    private:
        std::vector<QJSValue> m_oRecievers;
};
 
class cScriptReader: public QObject
{
    Q_OBJECT
 
    public:
        cScriptReader(cDynamicSampleReader* pReader, QJSEngine& oEngine);
        tResult Check();
 
        Q_INVOKABLE QVariant getNextSample();
 
        Q_INVOKABLE QVariant getLastSample();
 
        Q_INVOKABLE void requestSamples(const QString& strSubStream);
 
        Q_INVOKABLE void cancelRequest(const QString& strSubStream);
 
#ifdef DOXYGEN
    signals:
        void streamTypeChanged(QObject* type);
 
        void trigger(qint64 timestamp);
 
        void sample(const QVariant& sample);
#endif
 
        virtual tResult OnTrigger(tNanoSeconds tmTrigger) = 0;
 
    protected:
        void DiscardSamples();
        std::string GetName();
        virtual tResult ForwardStreamTypeToScriptHandler(QObject* oType) = 0;
        virtual std::pair<bool, bool> TriggerAndSampleCallbacks() const = 0;
        QJSEngine& m_oEngine;
 
    private:
        QVariantMap Transform(const iobject_ptr<const ISample>& pSample);
 
        cDynamicSampleReader* m_pReader = nullptr;
        std::mutex m_oSubStreamsLock;
        struct tSubStream
        {
            QString strName;
            cSampleCodecFactory oCodecFactory;
            std::unique_ptr<cImageConverter> pImageConverter;
        };
        bool m_bUseSampleSubStreamId = false;
        std::unordered_map<uint32_t, tSubStream> m_oSubStreams;
        std::unordered_map<std::string, object_ptr<IStreamingRequest>> m_oRequestedSubStreams;
        adtf::ucom::object_ptr<const adtf::streaming::IStreamType> m_pLastRequestType;
 
        static tSubStream GetSubStream(const iobject_ptr<const IStreamType>& pType);
};
 
class cAsyncScriptReader: public cScriptReader
{
    Q_OBJECT
 
    public:
        using cScriptReader::cScriptReader;
        tResult OnTrigger(tNanoSeconds tmTrigger) override;
 
    signals:
        void streamTypeChanged(QObject* type);
        void trigger(qint64 timestamp);
        void sample(const QVariant& sample);
        void triggerProcessed(qint64 timestamp);
 
    protected:
        tResult ForwardStreamTypeToScriptHandler(QObject* oType) override;
        std::pair<bool, bool> TriggerAndSampleCallbacks() const override;
};
 
class cSyncScriptReader: public cScriptReader
{
    Q_OBJECT
    Q_PROPERTY(QObject* streamTypeChanged READ getSyncStreamTypes)
    Q_PROPERTY(QObject* trigger READ getSyncTrigger)
    Q_PROPERTY(QObject* sample READ getSyncSample)
 
    public:
        cSyncScriptReader(cDynamicSampleReader* pReader, QJSEngine& oEngine);
        tResult OnTrigger(tNanoSeconds tmTrigger) override;
 
    protected:
        tResult ForwardStreamTypeToScriptHandler(QObject* oType) override;
        std::pair<bool, bool> TriggerAndSampleCallbacks() const override;
 
    private:
        QObject* getSyncStreamTypes()
        {
            return &m_oSyncStreamTypeRecievers;
        }
 
        QObject* getSyncTrigger()
        {
            return &m_oSyncTriggerRecievers;
        }
 
        QObject* getSyncSample()
        {
            return &m_oSyncSampleRecievers;
        }
 
        cSyncSignalRecievers m_oSyncStreamTypeRecievers;
        cSyncSignalRecievers m_oSyncTriggerRecievers;
        cSyncSignalRecievers m_oSyncSampleRecievers;
};
 
}
}
}