Source Code for Qt5 Video Display Plugin

Location

./src/examples/src/adtf/filters/qt/demo_qt_video_display/

Build Environment

To see how to set up the build environment have a look at ADTF CMake Environment

This implementation shows:

• how to work with Stream Meta Type adtf::streaming::ant::stream_meta_type_image
• how to implement a common adtf filter as Qt5 Display used by Qt5 ADTF XSystem UI Service
• how to display a video within adtf
• for this code you need to have installed Qt5, QTDIR environment variable must be set and the CMAKE_PREFIX_PATH variable must be set to the Qt SDK.

Remarks

• This UI Filter does only support pixel formats that are supported by QImage! Extend the code for your own needs.
• This UI Filter uses a simple implemented cVideoWidget class based on QWidget from Qt SDK.

Header

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
#include "video_widget.h"
 
#include <adtffiltersdk/adtf_filtersdk.h>
// always include filtersdk, systemsdk or streaming3 sdk BEFORE adtfui!!
#include <adtf_ui.h>
 
#include <QtWidgets>
 
using namespace adtf::base;
using namespace adtf::ucom;
using namespace adtf::streaming;
using namespace adtf::filter;
using namespace adtf::ui;
 
class cQtVideoFilter : public cQtUIFilter
{
    public:
        ADTF_CLASS_ID_NAME(cQtVideoFilter,
                           "demo_qt_video_display.ui_filter.adtf.cid",
                           "Qt5 Video Display");
        ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::ui::IQtXSystem));
 
    private:
        std::atomic_bool m_bStreamTypeChanged;
        std::atomic_bool m_bInvalidated;
 
        size_limited_sample_reader<1, false>*  m_pReader = nullptr;
 
        property_variable<uint32_t> m_nWidth  = 640;
        property_variable<uint32_t> m_nHeight = 480;
 
        property_variable<bool>  m_bKeepRatio    = true;
        property_variable<bool>  m_bFitToScreen  = true;
 
        tStreamImageFormat m_sCurrentFormat;
 
        cVideoWidget* m_pVideoWidget = nullptr;
 
    public:
        cQtVideoFilter();
 
        tResult Init(tInitStage eStage) override;
        tResult AcceptType(ISampleReader* pReader, const iobject_ptr<const IStreamType>& pType) override;
 
    protected:
        QWidget* CreateView() override;
        void    ReleaseView() override;
 
        tResult  OnTimer() override;
 
   private:
        object_ptr<IStreamType> GetStreamTypeFromProperties();
        tResult UpdateVideo();
 
};

Implementation

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#include "demo_qt_video_display.h"
 
//*************************************************************************************************
 
ADTF_PLUGIN("Qt5 Video Display Plugin", cQtVideoFilter)
 
//*************************************************************************************************
 
 
cQtVideoFilter::cQtVideoFilter(): adtf::ui::cQtUIFilter(), m_bStreamTypeChanged(true), m_pVideoWidget(nullptr)
{
    m_nWidth.SetDescription("Specified width for Sample dimension.");
    RegisterPropertyVariable("width", m_nWidth);
 
    m_nHeight.SetDescription("Specified height for Sample dimension.");
    RegisterPropertyVariable("height", m_nHeight);
 
    m_bFitToScreen.SetDescription("If enabled, the sample will be resized to the window dimension.");
    RegisterPropertyVariable("fit_to_screen", m_bFitToScreen);
 
    m_bKeepRatio.SetDescription("If enabled, the ratio of the Sample will be kept even when resized.");
    RegisterPropertyVariable("keep_ratio", m_bKeepRatio);
 
    m_pReader = CreateInputPin<size_limited_sample_reader<1, tFalse>>(
        "video", GetStreamTypeFromProperties(),
        // m_pReader is accessed from the UI thread, so the default processing in the trigger must be disabled.
        // Otherwise m_pReader would get corrupted due to to race conditions.
        false);
    set_description(*this, "video", "Input Pin for uncompressed video data streams to visualize.");
 
    // sets a short description for the component
    SetDescription("Use this filter to visualize uncompressed ADTF Video streams.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    set_help_link(*this, "$(ADTF_DIR)/doc/html/page_demo_qt_video_display.html");
}
 
tResult cQtVideoFilter::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(cQtUIFilter::Init(eStage));
 
    if (eStage == StageNormal)
    {
        adtf::ucom::object_ptr<IStreamType> pType = GetStreamTypeFromProperties();
        RETURN_IF_FAILED(m_pReader->SetType(pType));
        RETURN_IF_FAILED(AcceptType(m_pReader, pType));
    }
 
    RETURN_NOERROR;
}
 
object_ptr<IStreamType> cQtVideoFilter::GetStreamTypeFromProperties()
{
    m_sCurrentFormat.m_strFormatName = ADTF_IMAGE_FORMAT(RGB_32);
    m_sCurrentFormat.m_ui32Width = m_nWidth;
    m_sCurrentFormat.m_ui32Height = m_nHeight;
    m_sCurrentFormat.m_szMaxByteSize = 0;
    m_sCurrentFormat.m_ui8DataEndianess = PLATFORM_BYTEORDER;
    object_ptr<IStreamType> pType = make_object_ptr<cStreamType>(stream_meta_type_image());
    set_stream_type_image_format(*pType, m_sCurrentFormat);
    return pType;
}
 
QWidget* cQtVideoFilter::CreateView()
{
    m_pVideoWidget = new cVideoWidget(nullptr);
    m_pVideoWidget->SetFitToScreen(m_bFitToScreen);
    m_pVideoWidget->SetKeepRatio(m_bKeepRatio);
    return m_pVideoWidget;
}
 
void cQtVideoFilter::ReleaseView()
{
    m_pVideoWidget = nullptr;
}
 
tResult cQtVideoFilter::OnTimer()
{
    RETURN_IF_FAILED(adtf::ui::cQtUIFilter::OnTimer());
    RETURN_IF_FAILED(UpdateVideo());
    RETURN_NOERROR;
}
 
tResult cQtVideoFilter::AcceptType(ISampleReader* /*pReader*/, const iobject_ptr<const IStreamType>& pType)
{
    if (!pType.Get())
    {
        RETURN_ERROR(ERR_INVALID_TYPE);
    }
 
    RETURN_IF_FAILED(adtf::streaming::get_stream_type_image_format(m_sCurrentFormat, *pType.Get()));
    RETURN_NOERROR;
}
 
tResult cQtVideoFilter::UpdateVideo()
{
    // We are only interested in the last sample and only if its new (thus no use of GetLastSample).
    adtf::ucom::object_ptr<const adtf::streaming::ISample> pSample;
    while (IS_OK(m_pReader->GetNextSample(pSample)))
    {
    }
 
    if (pSample)
    {
        m_pVideoWidget->UpdateSample(m_sCurrentFormat, pSample);
    }
 
    RETURN_NOERROR;
}