videostream.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __VIDEOSTREAM_H
#define __VIDEOSTREAM_H
 
#include <atomic>
#include <functional>
#include <set>
#include <string>
#include <vector>
 
extern "C" {
#include <libavcodec/avcodec.h>
}
 
#include <vdr/thread.h>
 
#include "queue.h"
#include "videofilter.h"
 
class cDrmBuffer;
class cSoftHdConfig;
class cVideoDecoder;
class cVideoRender;
 
enum HardwareQuirks {
    QUIRK_NO_HW_DEINT             = 1 << 0,     
    QUIRK_CODEC_FLUSH_WORKAROUND  = 1 << 1,     
    QUIRK_CODEC_NEEDS_EXT_INIT    = 1 << 2,     
    QUIRK_CODEC_SKIP_FIRST_FRAMES = 1 << 3,     
    QUIRK_CODEC_SKIP_NUM_FRAMES   = 2     ,     
    QUIRK_CODEC_DISABLE_MPEG_HW   = 1 << 4,     
    QUIRK_CODEC_DISABLE_H264_HW   = 1 << 5      
};
 
class cVideoStream : public cThread {
public:
    virtual ~cVideoStream(void);
 
    void DecodeInput(void);
    bool IsInterlaced(void) { return false; };
 
    void Open(AVCodecID, AVCodecParameters * = nullptr, AVRational = { .num = 1, .den = 90000 });
    void Exit(void);
    void ClearVdrCoreToDecoderQueue(void);
    void FlushDecoder(void);
    void CloseDecoder(void);
    bool PushAvPacket(AVPacket *avpkt);
    void Flush(void);
 
    // decoding thread
    void Stop(void);
    void Halt(void) { m_mutex.lock(); };
    void Resume(void) { m_mutex.unlock(); };
 
    // getters and setters
    cVideoDecoder *Decoder(void) { return m_pDecoder; };
    void StartDecoder();
    size_t GetAvPacketsFilled(void) { return m_packets.Size(); };
    bool IsInputBufferFull(void) { return m_packets.Size() >= VIDEO_PACKET_MAX; };
    enum AVCodecID GetCodecId(void) { return m_codecId; };
    void ResetTrickSpeedFramesSentCounter(void) { m_sentTrickPkts = 0; };
    bool HasInputPts(void) { return m_inputPts != AV_NOPTS_VALUE; }
    int64_t GetInputPtsMs(void);
    int64_t GetInputPts(void) { return m_inputPts; };
    void ResetInputPts(void) { m_inputPts = AV_NOPTS_VALUE; };
    void GetVideoSize(int *, int *, double *);
    int GetVideoPacketMax(void) { return VIDEO_PACKET_MAX; };
 
    // Filter
    void CancelFilterThread(void);
    void ResetFilterThreadNeededCheck() { m_checkFilterThreadNeeded = true; };
 
    virtual void SetDeinterlacerDeactivated(bool deactivate) { m_deinterlacerDeactivated = deactivate; };
    bool IsDeinterlacerDeactivated(void) { return m_deinterlacerDeactivated; };
    int HardwareQuirks(void) { return m_hardwareQuirks; };
    void DisableDeint(bool disable) { m_userDisabledDeinterlacer = disable; };
    void SetStartDecodingWithIFrame(bool enable) { m_startDecodingWithIFrame = enable; };
    void SetParseH264Dimensions(bool enable) { m_parseH264Dimensions = enable; };
    void SetDecoderFallbackToSwNumPkts(int numPackets) { m_decoderFallbackToSwNumPkts = numPackets; };
 
protected:
    cVideoStream(cVideoRender *, cQueue<cDrmBuffer> *, cSoftHdConfig *, bool, std::function<void(AVFrame *)>);
    virtual void Action(void);
 
private:
    cSoftHdConfig *m_pConfig;           
    cVideoDecoder *m_pDecoder;          
    cVideoRender *m_pRender;            
    const char *m_identifier;           
    std::function<void(AVFrame *)> m_frameOutput;   
    cQueue<cDrmBuffer> *m_pDrmBufferQueue;          
    cVideoFilter m_videoFilter;         
    std::mutex m_mutex;                 
 
    bool m_checkFilterThreadNeeded;                 
    int m_hardwareQuirks;                           
    bool m_userDisabledDeinterlacer = false;        
    bool m_deinterlacerDeactivated;                 
    bool m_startDecodingWithIFrame = false;         
    bool m_parseH264Dimensions = false;             
    int m_decoderFallbackToSwNumPkts = 22;          
 
    constexpr static int VIDEO_PACKET_MAX = 192;    
    cQueue<AVPacket> m_packets{VIDEO_PACKET_MAX};   
 
    enum AVCodecID m_codecId = AV_CODEC_ID_NONE;    
    AVCodecParameters *m_pPar = nullptr;            
    std::atomic<struct AVRational> m_timebase;      
    int m_trickpkts;                                
    int m_sentTrickPkts = 0;                        
    volatile bool m_newStream = false;              
    bool m_interlaced;                              
 
    int64_t m_inputPts = AV_NOPTS_VALUE;            
 
    // h264 parsing
    std::vector<std::string> m_naluTypesAtStart;    
    int m_numIFrames = 0;                           
    int m_logPackets = 0;                           
    int m_dropInvalidPackets = 0;                   
    std::set<int> m_dpbFrames;                      
    int m_maxFrameNum = 1;                          
    int m_log2MaxFrameNumMinus4 = -4;               
    int m_ppsNumRefIdxL0DefaultActiveMinus1 = -1;   
    int m_ppsNumRefIdxL1DefaultActiveMinus1 = -1;   
    bool m_isResend = false;                        
 
    void RenderFrame(AVFrame *);
    void CheckForcingFrameDecode(void);
    void OpenDecoder(void);
    bool ParseH264Packet(AVPacket *);
};
 
class cMainVideoStream : public cVideoStream {
public:
    cMainVideoStream(cVideoRender *render, cQueue<cDrmBuffer> *buf, cSoftHdConfig *config, std::function<void(AVFrame *)> fn)
        : cVideoStream(render, buf, config, false, fn) {};
};
 
class cPipVideoStream : public cVideoStream {
public:
    cPipVideoStream(cVideoRender *render, cQueue<cDrmBuffer> *buf, cSoftHdConfig *config, std::function<void(AVFrame *)> fn)
        : cVideoStream(render, buf, config, true, fn) {};
    void SetDeinterlacerDeactivated(bool) override {}; // deinterlacing is permanently disabled
};
 
#endif