videostream.h

Go to the documentation of this file.

 
#ifndef __VIDEOSTREAM_H
#define __VIDEOSTREAM_H
 
#include <atomic>
#include <functional>
#include <string>
 
extern "C" {
#include <libavcodec/avcodec.h>
}
 
#include "queue.h"
#include "threads.h"
 
#define VIDEO_BUFFER_SIZE (512 * 1024)  
#define VIDEO_PACKET_MAX 192            
 
// Hardware quirks, that are set depending on the hardware used
#define QUIRK_NO_HW_DEINT               1 << 0     
#define QUIRK_CODEC_FLUSH_WORKAROUND    1 << 1     
#define QUIRK_CODEC_NEEDS_EXT_INIT      1 << 2     
#define QUIRK_CODEC_SKIP_FIRST_FRAMES   1 << 3     
#define QUIRK_CODEC_SKIP_NUM_FRAMES     2          
#define QUIRK_CODEC_DISABLE_MPEG_HW     1 << 4     
#define QUIRK_CODEC_DISABLE_H264_HW     1 << 5     
 
class cSoftHdConfig;
class cVideoDecoder;
class cVideoRender;
 
class cVideoStream
{
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);
 
    // 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 *);
 
    // decoding thread
    void ExitDecodingThread(void);
    void DecodingThreadHalt(void) { m_pDecodingThread->Halt(); };
    void DecodingThreadResume(void) { m_pDecodingThread->Resume(); };
 
    // 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 *)>);
 
private:
    cSoftHdConfig *m_pConfig;           
    cVideoDecoder *m_pDecoder;          
    cVideoRender *m_pRender;            
    cFilterThread *m_pFilterThread;     
    const char *m_identifier;           
    std::string m_filterThreadName;     
    std::string m_decodingThreadName;   
    std::function<void(AVFrame *)> m_frameOutput;   
    cQueue<cDrmBuffer> *m_pDrmBufferQueue;          
 
    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;          
 
    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;                     
 
    cDecodingThread *m_pDecodingThread;    
    int64_t m_inputPts = AV_NOPTS_VALUE;   
 
    void RenderFrame(AVFrame *);
    void CheckForcingFrameDecode(void);
    void OpenDecoder(void);
};
 
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