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/remux.h>
#include <vdr/thread.h>
 
#include "queue.h"
#include "videofilter.h"
 
class cDrmBuffer;
class cSoftHdConfig;
class cVideoDecoder;
class cVideoRender;
 
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 = PTSTICKS });
    void Exit(void);
    void ClearVdrCoreToDecoderQueue(void);
    void FlushDecoder(void);
    void CloseDecoder(void);
    bool PushAvPacket(AVPacket *avpkt);
    bool Drain(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; };
    bool BuffersEmpty(void);
    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) { return m_inputPts * 1000 * av_q2d(m_timebase); };
    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; m_useDeinterlacer = false; };
 
    virtual void SetDeinterlacerDeactivated(bool deactivate) { m_deinterlacerDeactivated = deactivate; };
    bool IsDeinterlacerDeactivated(void) { return m_deinterlacerDeactivated; };
    void DisableDeint(bool disable) { m_userDisabledDeinterlacer = disable; };
    void SetDecoderFallbackToSwNumPkts(int numPackets) { m_decoderFallbackToSwNumPkts = numPackets; };
 
protected:
    cVideoStream(cVideoRender *, int, 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_useDeinterlacer = false;                 
    int m_decoderFallbackToSwNumPkts = 22;          
 
    constexpr static int VIDEO_PACKET_MAX = 192;    
    cQueue<AVPacket> m_packets{VIDEO_PACKET_MAX};   
    constexpr static int AV_SYNC_BORDER_MS = 5000;  
 
    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;                        
    std::atomic<bool> m_newStream = false;          
    bool m_interlaced;                              
    double m_framerate = 0.0;                       
 
    int64_t m_inputPts = AV_NOPTS_VALUE;            
    int64_t m_ptsForFramerateDetection = AV_NOPTS_VALUE; 
    int64_t m_lastDecodedPts = 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 SendPacket(AVPacket *);
    int ReceiveFrame(AVFrame **);
    void RenderFrame(AVFrame *);
    void CheckForcingFrameDecode(void);
    void OpenDecoder(void);
    bool ParseH264Packet(AVPacket *);
    bool PacketDropNeeded(AVPacket *);
    int64_t PtsToMs(int64_t pts) { return pts * av_q2d(m_timebase) * 1000; };
};
 
class cMainVideoStream : public cVideoStream {
public:
    cMainVideoStream(cVideoRender *render, int hardwareQuirks, cQueue<cDrmBuffer> *buf, cSoftHdConfig *config, std::function<void(AVFrame *)> fn)
        : cVideoStream(render, hardwareQuirks, buf, config, false, fn) {};
};
 
class cPipVideoStream : public cVideoStream {
public:
    cPipVideoStream(cVideoRender *render, int hardwareQuirks, cQueue<cDrmBuffer> *buf, cSoftHdConfig *config, std::function<void(AVFrame *)> fn)
        : cVideoStream(render, hardwareQuirks, buf, config, true, fn) {};
    void SetDeinterlacerDeactivated(bool) override {}; // deinterlacing is permanently disabled
};
 
#endif