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>
 
namespace adtf
{
namespace javascript
{
namespace scripting
{

class cImageConverter
{
public:
    cImageConverter(const adtf::streaming::IStreamType& oType);
    QImage convert(const adtf::streaming::ISample& oSample);
 
private:
    adtf::streaming::tStreamImageFormat m_sInputFormat;
};
 
inline tResult script_error_to_result(const QJSValue& oScriptResult)
{
    if (oScriptResult.isError())
    {
        RETURN_ERROR_DESC(ERR_FAILED, "Uncaught script exception at %s:%d: %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(adtf::streaming::cDynamicSampleReader* pReader, QJSEngine& oEngine);
    tResult Check();

    Q_INVOKABLE QVariant getNextSample();

    Q_INVOKABLE QVariant getLastSample();

    Q_INVOKABLE void requestSamples(const QVariant& oSubStreamFilter);

    Q_INVOKABLE void cancelRequest(const QVariant& oSubStreamFilter);

    Q_PROPERTY(QVariantList requests READ requests NOTIFY requestsChanged)
 
signals:
#ifdef DOXYGEN
    void streamTypeChanged(QObject* type);

    void trigger(qint64 timestamp);

    void sample(const QVariant& sample);
#endif

    void requestsChanged();
 
public:
    const QVariantList& requests() const noexcept;
 
    virtual tResult OnTrigger(adtf::base::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 adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample);
 
    adtf::streaming::cDynamicSampleReader* m_pReader = nullptr;
    mutable std::mutex m_oSubStreamsLock;
 
    // Empty state indicates that decoder initialization has failed.
    using tSubsStreamDecoder =
        std::variant<std::monostate, adtf::mediadescription::cSampleCodecFactory, cImageConverter>;
 
    struct tDecodableSubStream
    {
        tDecodableSubStream(const QString strName,
                            const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pType):
            strName(strName), pType(pType)
        {
        }
        QString strName;
        adtf::ucom::object_ptr<const adtf::streaming::IStreamType> pType;
        // Non-zero pointer indicates that stream is currently matches by requests.
        std::unique_ptr<tSubsStreamDecoder> pDecoder;
    };
 
    struct tRequestableSubStream
    {
        tRequestableSubStream(uint32_t nId): nId(nId)
        {
        }
        uint32_t nId;
        adtf::ucom::object_ptr<adtf::streaming::IStreamingRequest> pRequest;
    };
 
    // Can only contain QString and QRegularExpression. Specifies substream names.
    QVariantList m_oRequestFilters;
 
    bool m_bUseSampleSubStreamId = false;
    // Built from type received in AcceptType
    // Contains only an entry for id==0, if m_bUseSampleSubStreamId is not set.
    std::unordered_map<uint32_t, tDecodableSubStream> m_oDecodableSubStreams;
    // Built from type received in SynchronousTypeUpdate
    std::unordered_map<QString, tRequestableSubStream> m_oRequestableSubStream;
 
    static std::unique_ptr<tSubsStreamDecoder>
        GetStreamDecoder(const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pType);
 
    static bool MatchesFilter(const QVariant& oRequestFilter, const QString& strSubStream) noexcept;
    bool MatchesCurrentFilters(const QString& strSubStream) const noexcept;

};

class cAsyncScriptReader : public cScriptReader
{
    Q_OBJECT
 
public:
    using cScriptReader::cScriptReader;
    tResult OnTrigger(adtf::base::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(adtf::streaming::cDynamicSampleReader* pReader, QJSEngine& oEngine);
    tResult OnTrigger(adtf::base::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;
};
 
} // namespace scripting
} // namespace javascript
} // namespace adtf