videostream.h

Go to the documentation of this file.

 
#ifndef __VIDEOSTREAM_H
#define __VIDEOSTREAM_H
 
#include <atomic>
#include <functional>
#include <vector>
 
extern "C" {
#include <libavfilter/avfilter.h>
#include <libavcodec/avcodec.h>
#include <libavutil/avutil.h>
}
 
#include "codec_video.h"
#include "videorender.h"
#include "pes.h"
#include "threads.h"
#include "drmbuffer.h"
#include "queue.h"
 
#define VIDEO_BUFFER_SIZE (512 * 1024)  
#define VIDEO_PACKET_MAX 192            
 
class cVideoDecoder;
class cVideoRender;
 
class cVideoStream
{
public:
    cVideoStream(cVideoRender *, cQueue<cDrmBuffer> *, cSoftHdConfig *, const char *, std::function<void(AVFrame *)>);
    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 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; };
 
    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; };
 
private:
    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 = false;         
 
    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;             
    bool m_interlaced;                     
 
    cDecodingThread *m_pDecodingThread;    
    int64_t m_inputPts = AV_NOPTS_VALUE;   
 
    void RenderFrame(AVFrame *);
};
 
#endif