#include <RenderManager.h>
 | 
|   | CRenderManager (CDVDClock &clock, IRenderMsg *player) | 
|   | 
| virtual  | ~CRenderManager () | 
|   | 
| void  | GetVideoRect (CRect &source, CRect &dest, CRect &view) const | 
|   | 
| float  | GetAspectRatio () const | 
|   | 
| unsigned int  | GetOrientation () const | 
|   | 
| void  | FrameMove () | 
|   | 
| void  | FrameWait (std::chrono::milliseconds duration) | 
|   | 
| void  | Render (bool clear, DWORD flags=0, DWORD alpha=255, bool gui=true) | 
|   | 
| bool  | IsVideoLayer () | 
|   | 
| RESOLUTION  | GetResolution () | 
|   | 
| void  | UpdateResolution () | 
|   | 
| void  | TriggerUpdateResolution (float fps, int width, int height, std::string &stereomode) | 
|   | 
| void  | SetViewMode (int iViewMode) | 
|   | 
| void  | PreInit () | 
|   | 
| void  | UnInit () | 
|   | 
| bool  | Flush (bool wait, bool saveBuffers) | 
|   | 
| bool  | IsConfigured () const | 
|   | 
| void  | ToggleDebug () | 
|   | 
| void  | ToggleDebugVideo () | 
|   | 
| void  | SetSubtitleVerticalPosition (const int value, bool save) | 
|   | Set the subtitle vertical position, it depends on current screen resolution.  
  | 
|   | 
| unsigned int  | AllocRenderCapture () | 
|   | 
| void  | ReleaseRenderCapture (unsigned int captureId) | 
|   | 
| void  | StartRenderCapture (unsigned int captureId, unsigned int width, unsigned int height, int flags) | 
|   | 
| bool  | RenderCaptureGetPixels (unsigned int captureId, unsigned int millis, uint8_t *buffer, unsigned int size) | 
|   | 
| bool  | Supports (ERENDERFEATURE feature) const | 
|   | 
| bool  | Supports (ESCALINGMETHOD method) const | 
|   | 
| int  | GetSkippedFrames () | 
|   | 
| bool  | Configure (const VideoPicture &picture, float fps, unsigned int orientation, int buffers=0) | 
|   | 
| bool  | AddVideoPicture (const VideoPicture &picture, volatile std::atomic_bool &bStop, EINTERLACEMETHOD deintMethod, bool wait) | 
|   | 
| void  | AddOverlay (std::shared_ptr< CDVDOverlay > o, double pts) | 
|   | 
| void  | ShowVideo (bool enable) | 
|   | 
| int  | WaitForBuffer (volatile std::atomic_bool &bStop, std::chrono::milliseconds timeout=std::chrono::milliseconds(100)) | 
|   | 
| bool  | GetStats (int &lateframes, double &pts, int &queued, int &discard) | 
|   | 
| void  | DiscardBuffer () | 
|   | 
| void  | SetDelay (int delay) | 
|   | 
| int  | GetDelay () | 
|   | 
| void  | SetVideoSettings (const CVideoSettings &settings) | 
|   | 
◆ EPRESENTMETHOD
| Enumerator | 
|---|
| PRESENT_METHOD_SINGLE  |  | 
| PRESENT_METHOD_BLEND  |  | 
| PRESENT_METHOD_BOB  |  | 
 
 
◆ EPRESENTSTEP
| Enumerator | 
|---|
| PRESENT_IDLE  |  | 
| PRESENT_FLIP  |  | 
| PRESENT_FRAME  |  | 
| PRESENT_FRAME2  |  | 
| PRESENT_READY  |  | 
 
 
◆ ERENDERSTATE
| Enumerator | 
|---|
| STATE_UNCONFIGURED  |  | 
| STATE_CONFIGURING  |  | 
| STATE_CONFIGURED  |  | 
 
 
◆ CRenderManager()
◆ ~CRenderManager()
  
  
      
        
          | CRenderManager::~CRenderManager  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
virtual   | 
  
 
 
◆ AddOverlay()
      
        
          | void CRenderManager::AddOverlay  | 
          ( | 
          std::shared_ptr< CDVDOverlay > |           o,  | 
        
        
           | 
           | 
          double |           pts ) | 
        
      
 
 
◆ AddVideoPicture()
◆ AllocRenderCapture()
      
        
          | unsigned int CRenderManager::AllocRenderCapture  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ CheckEnableClockSync()
  
  
      
        
          | void CRenderManager::CheckEnableClockSync  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ Configure() [1/2]
  
  
      
        
          | bool CRenderManager::Configure  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ Configure() [2/2]
      
        
          | bool CRenderManager::Configure  | 
          ( | 
          const VideoPicture & |           picture,  | 
        
        
           | 
           | 
          float |           fps,  | 
        
        
           | 
           | 
          unsigned int |           orientation,  | 
        
        
           | 
           | 
          int |           buffers = 0 ) | 
        
      
 
 
◆ CreateRenderer()
  
  
      
        
          | void CRenderManager::CreateRenderer  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ DeleteRenderer()
  
  
      
        
          | void CRenderManager::DeleteRenderer  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ DiscardBuffer()
      
        
          | void CRenderManager::DiscardBuffer  | 
          ( | 
           | ) | 
           | 
        
      
 
Video player call this on flush in order to discard any queued frames 
 
 
◆ Flush()
◆ FrameMove()
      
        
          | void CRenderManager::FrameMove  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ FrameWait()
      
        
          | void CRenderManager::FrameWait  | 
          ( | 
          std::chrono::milliseconds |           duration | ) | 
           | 
        
      
 
 
◆ GetAspectRatio()
      
        
          | float CRenderManager::GetAspectRatio  | 
          ( | 
           | ) | 
           const | 
        
      
 
 
◆ GetDelay()
  
  
      
        
          | int CRenderManager::GetDelay  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ GetOrientation()
      
        
          | unsigned int CRenderManager::GetOrientation  | 
          ( | 
           | ) | 
           const | 
        
      
 
 
◆ GetResolution()
◆ GetSkippedFrames()
  
  
      
        
          | int CRenderManager::GetSkippedFrames  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ GetStats()
      
        
          | bool CRenderManager::GetStats  | 
          ( | 
          int & |           lateframes,  | 
        
        
           | 
           | 
          double & |           pts,  | 
        
        
           | 
           | 
          int & |           queued,  | 
        
        
           | 
           | 
          int & |           discard ) | 
        
      
 
Can be called by player for lateness detection. This is done best by looking at the end of the queue. 
 
 
◆ GetVideoRect()
◆ IsConfigured()
      
        
          | bool CRenderManager::IsConfigured  | 
          ( | 
           | ) | 
           const | 
        
      
 
 
◆ IsGuiLayer()
  
  
      
        
          | bool CRenderManager::IsGuiLayer  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ IsPresenting()
  
  
      
        
          | bool CRenderManager::IsPresenting  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ IsVideoLayer()
      
        
          | bool CRenderManager::IsVideoLayer  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ ManageCaptures()
  
  
      
        
          | void CRenderManager::ManageCaptures  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ PreInit()
      
        
          | void CRenderManager::PreInit  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ PrepareNextRender()
  
  
      
        
          | void CRenderManager::PrepareNextRender  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ PresentBlend()
◆ PresentFields()
◆ PresentSingle()
◆ ReleaseRenderCapture()
      
        
          | void CRenderManager::ReleaseRenderCapture  | 
          ( | 
          unsigned int |           captureId | ) | 
           | 
        
      
 
 
◆ RemoveCaptures()
  
  
      
        
          | void CRenderManager::RemoveCaptures  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ Render()
◆ RenderCapture()
◆ RenderCaptureGetPixels()
      
        
          | bool CRenderManager::RenderCaptureGetPixels  | 
          ( | 
          unsigned int |           captureId,  | 
        
        
           | 
           | 
          unsigned int |           millis,  | 
        
        
           | 
           | 
          uint8_t * |           buffer,  | 
        
        
           | 
           | 
          unsigned int |           size ) | 
        
      
 
 
◆ SetDelay()
  
  
      
        
          | void CRenderManager::SetDelay  | 
          ( | 
          int |           delay | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ SetSubtitleVerticalPosition()
      
        
          | void CRenderManager::SetSubtitleVerticalPosition  | 
          ( | 
          const int |           value,  | 
        
        
           | 
           | 
          bool |           save ) | 
        
      
 
Set the subtitle vertical position, it depends on current screen resolution. 
- Parameters
 - 
  
    | value | The subtitle position in pixels  | 
    | save | If true, the value will be saved to resolution info  | 
  
   
 
 
◆ SetVideoSettings()
◆ SetViewMode()
      
        
          | void CRenderManager::SetViewMode  | 
          ( | 
          int |           iViewMode | ) | 
           | 
        
      
 
 
◆ ShowVideo()
      
        
          | void CRenderManager::ShowVideo  | 
          ( | 
          bool |           enable | ) | 
           | 
        
      
 
 
◆ StartRenderCapture()
      
        
          | void CRenderManager::StartRenderCapture  | 
          ( | 
          unsigned int |           captureId,  | 
        
        
           | 
           | 
          unsigned int |           width,  | 
        
        
           | 
           | 
          unsigned int |           height,  | 
        
        
           | 
           | 
          int |           flags ) | 
        
      
 
 
◆ Supports() [1/2]
◆ Supports() [2/2]
◆ ToggleDebug()
      
        
          | void CRenderManager::ToggleDebug  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ ToggleDebugVideo()
      
        
          | void CRenderManager::ToggleDebugVideo  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ TriggerUpdateResolution()
      
        
          | void CRenderManager::TriggerUpdateResolution  | 
          ( | 
          float |           fps,  | 
        
        
           | 
           | 
          int |           width,  | 
        
        
           | 
           | 
          int |           height,  | 
        
        
           | 
           | 
          std::string & |           stereomode ) | 
        
      
 
 
◆ UnInit()
      
        
          | void CRenderManager::UnInit  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ UpdateLatencyTweak()
  
  
      
        
          | void CRenderManager::UpdateLatencyTweak  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ UpdateResolution()
      
        
          | void CRenderManager::UpdateResolution  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ WaitForBuffer()
      
        
          | int CRenderManager::WaitForBuffer  | 
          ( | 
          volatile std::atomic_bool & |           bStop,  | 
        
        
           | 
           | 
          std::chrono::milliseconds |           timeout = std::chrono::milliseconds(100) ) | 
        
      
 
If player uses buffering it has to wait for a buffer before it calls AddVideoPicture and AddOverlay. It waits for max 50 ms before it returns -1 in case no buffer is available. Player may call this in a loop and decides by itself when it wants to drop a frame. 
 
 
◆ m_bRenderGUI
  
  
      
        
          | bool CRenderManager::m_bRenderGUI = true | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_bTriggerUpdateResolution
  
  
      
        
          | bool CRenderManager::m_bTriggerUpdateResolution = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_captCritSect
  
  
      
        
          | CCriticalSection CRenderManager::m_captCritSect | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_captures
◆ m_captureWaitCounter
  
  
      
        
          | unsigned int CRenderManager::m_captureWaitCounter = 0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_clockSync
◆ m_datalock
  
  
      
        
          | CCriticalSection CRenderManager::m_datalock | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_debugRenderer
◆ m_debugTimer
◆ m_discard
  
  
      
        
          | std::deque<int> CRenderManager::m_discard | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_displayLatency
  
  
      
        
          | double CRenderManager::m_displayLatency = 0.0 | 
         
       
   | 
  
protected   | 
  
 
Display latency updated in PrepareNextRender in DVD clock units, includes m_latencyTweak. 
 
 
◆ m_dvdClock
◆ m_flushEvent
  
  
      
        
          | CEvent CRenderManager::m_flushEvent | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_forceNext
  
  
      
        
          | bool CRenderManager::m_forceNext = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_fps
  
  
      
        
          | float CRenderManager::m_fps = 0.0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_free
  
  
      
        
          | std::deque<int> CRenderManager::m_free | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_hasCaptures
  
  
      
        
          | bool CRenderManager::m_hasCaptures = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_initEvent
  
  
      
        
          | CEvent CRenderManager::m_initEvent | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_lateframes
  
  
      
        
          | int CRenderManager::m_lateframes = -1 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_latencyTweak
  
  
      
        
          | double CRenderManager::m_latencyTweak = 0.0 | 
         
       
   | 
  
protected   | 
  
 
Display latency tweak value from AdvancedSettings for the current refresh rate in milliseconds 
 
 
◆ m_nextCaptureId
  
  
      
        
          | unsigned int CRenderManager::m_nextCaptureId = 0 | 
         
       
   | 
  
staticprotected   | 
  
 
 
◆ m_NumberBuffers
  
  
      
        
          | int CRenderManager::m_NumberBuffers = 0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_orientation
  
  
      
        
          | unsigned int CRenderManager::m_orientation = 0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_overlays
◆ m_pConfigPicture
  
  
      
        
          | std::unique_ptr<VideoPicture> CRenderManager::m_pConfigPicture | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_picture
◆ m_playerPort
◆ m_pRenderer
◆ m_presentevent
◆ m_presentlock
  
  
      
        
          | CCriticalSection CRenderManager::m_presentlock | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_presentpts
  
  
      
        
          | double CRenderManager::m_presentpts = 0.0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_presentsource
  
  
      
        
          | int CRenderManager::m_presentsource = 0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_presentsourcePast
  
  
      
        
          | int CRenderManager::m_presentsourcePast = -1 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_presentstep
◆ m_presentTimer
◆ m_Queue
◆ m_queued
  
  
      
        
          | std::deque<int> CRenderManager::m_queued | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_QueueSize
  
  
      
        
          | int CRenderManager::m_QueueSize = 2 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_QueueSkip
  
  
      
        
          | int CRenderManager::m_QueueSkip = 0 | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_renderDebug
  
  
      
        
          | bool CRenderManager::m_renderDebug = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_renderDebugVideo
  
  
      
        
          | bool CRenderManager::m_renderDebugVideo = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_renderedOverlay
  
  
      
        
          | bool CRenderManager::m_renderedOverlay = false | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_renderState
◆ m_showVideo
  
  
      
        
          | std::atomic_bool CRenderManager::m_showVideo = {false} | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_stateEvent
  
  
      
        
          | CEvent CRenderManager::m_stateEvent | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_statelock
  
  
      
        
          | CCriticalSection CRenderManager::m_statelock | 
         
       
   | 
  
mutableprotected   | 
  
 
 
◆ m_videoDelay
  
  
      
        
          | std::atomic_int CRenderManager::m_videoDelay = {} | 
         
       
   | 
  
protected   | 
  
 
 
The documentation for this class was generated from the following files: