videooutbase.h

Go to the documentation of this file.

// -*- Mode: c++ -*-

#ifndef VIDEOOUTBASE_H_
#define VIDEOOUTBASE_H_

extern "C" {
#include "frame.h"
#include "filter.h"
}

#include <qframe.h>
#include <qptrqueue.h>
#include <qptrlist.h>
#include "videobuffers.h"
#include "mythcodecid.h"
#include "videoouttypes.h"

using namespace std;

class NuppelVideoPlayer;
class OSD;
class OSDSurface;
class FilterChain;
class FilterManager;
class VideoDisplayProfile;

extern "C" {
struct ImgReSampleContext;
}

class VideoOutput
{
  public:
    static VideoOutput *Create(
        const QString &decoder,   MythCodecID  codec_id,
        void          *codec_priv,
        const QSize   &video_dim, float        video_aspect,
        WId            win_id,    const QRect &display_rect,
        WId            embed_id);

    VideoOutput();
    virtual ~VideoOutput();

    virtual bool Init(int width, int height, float aspect,
                      WId winid, int winx, int winy, int winw, 
                      int winh, WId embedid = 0);
    virtual void InitOSD(OSD *osd);
    virtual void SetVideoFrameRate(float);

    virtual bool SetDeinterlacingEnabled(bool);
    virtual bool SetupDeinterlace(bool i, const QString& ovrf="");
    virtual void FallbackDeint(void);
    virtual void BestDeint(void);
    virtual bool NeedsDoubleFramerate(void) const;
    virtual bool IsBobDeint(void) const;
    virtual bool IsExtraProcessingRequired(void) const;
    virtual bool ApproveDeintFilter(const QString& filtername) const;

    virtual void PrepareFrame(VideoFrame *buffer, FrameScanType) = 0;
    virtual void Show(FrameScanType) = 0;

    virtual bool InputChanged(const QSize &input_size,
                              float        aspect,
                              MythCodecID  myth_codec_id,
                              void        *codec_private);
    virtual void VideoAspectRatioChanged(float aspect);

    virtual void EmbedInWidget(WId wid, int x, int y, int w, int h);
    virtual void StopEmbedding(void);
    virtual void ResizeForGui(void) {;} 
    virtual void ResizeForVideo(void) {;}

    virtual void MoveResize(void);
    virtual void Zoom(ZoomDirection direction);
 
    virtual void GetDrawSize(int &xoff, int &yoff, int &width, int &height);
    virtual void GetOSDBounds(QRect &visible, QRect &total,
                              float &pixelAspect, float &fontScale,
                              float themeaspect) const;

    virtual int GetRefreshRate(void) = 0;

    virtual void DrawSlice(VideoFrame *frame, int x, int y, int w, int h);

    virtual void DrawUnusedRects(bool sync = true) = 0;

    virtual float GetDisplayAspect(void) const { return display_aspect; }

    AspectOverrideMode GetAspectOverride(void) { return aspectoverride; }
    void ToggleAspectOverride(
        AspectOverrideMode aspectOverrideMode = kAspect_Toggle);

    AdjustFillMode GetAdjustFill(void) { return adjustfill; }
    void ToggleAdjustFill(AdjustFillMode adjustFillMode = kAdjustFill_Toggle);

    // pass in null to use the pause frame, if it exists.
    virtual void ProcessFrame(VideoFrame *frame, OSD *osd,
                              FilterChain *filterList,
                              NuppelVideoPlayer *pipPlayer) = 0;

    void ExposeEvent(void) { needrepaint = true; }

    PictureAttributeSupported GetSupportedPictureAttributes(void) const
        { return supported_attributes; }
    int         ChangePictureAttribute(PictureAttribute, bool direction);
    virtual int SetPictureAttribute(PictureAttribute, int newValue);
    int         GetPictureAttribute(PictureAttribute) const;
    virtual void InitPictureAttributes(void);

    bool AllowPreviewEPG(void) { return allowpreviewepg; }

    virtual bool hasMCAcceleration(void) const { return false; }
    virtual bool hasIDCTAcceleration(void) const { return false; }
    virtual bool hasVLDAcceleration(void) const { return false; }

    virtual void SetFramesPlayed(long long fp) { framesPlayed = fp; };
    virtual long long GetFramesPlayed(void) { return framesPlayed; };

    bool IsErrored() { return errored; }

    // Video Buffer Management
    void SetPrebuffering(bool normal) { vbuffers.SetPrebuffering(normal); }
    virtual void ClearAfterSeek(void) { vbuffers.ClearAfterSeek(); }
    bool WaitForAvailable(uint w) { return vbuffers.WaitForAvailable(w); }

    virtual int ValidVideoFrames(void) const
        { return vbuffers.ValidVideoFrames(); }
    int FreeVideoFrames(void) { return vbuffers.FreeVideoFrames(); }
    bool EnoughFreeFrames(void) { return vbuffers.EnoughFreeFrames(); }
    bool EnoughDecodedFrames(void) { return vbuffers.EnoughDecodedFrames(); }
    bool EnoughPrebufferedFrames(void) { return vbuffers.EnoughPrebufferedFrames(); }

    bool IsEmbedding(void) { return embedding; }

    virtual VideoFrame *GetNextFreeFrame(bool with_lock = false,
                                         bool allow_unsafe = false)
        { return vbuffers.GetNextFreeFrame(with_lock, allow_unsafe); }
    virtual void ReleaseFrame(VideoFrame *frame) { vbuffers.ReleaseFrame(frame); }
    virtual void DeLimboFrame(VideoFrame *frame) { vbuffers.DeLimboFrame(frame); }
    virtual void StartDisplayingFrame(void) { vbuffers.StartDisplayingFrame(); }
    virtual void DoneDisplayingFrame(void) { vbuffers.DoneDisplayingFrame(); }
    virtual void DiscardFrame(VideoFrame *frame) { vbuffers.DiscardFrame(frame); }
    virtual void DiscardFrames(bool kf) { vbuffers.DiscardFrames(kf); }

    virtual void CheckFrameStates(void) { }

    VideoFrame *GetLastDecodedFrame(void) { return vbuffers.GetLastDecodedFrame(); }

    VideoFrame *GetLastShownFrame(void)  { return vbuffers.GetLastShownFrame(); }

    QString GetFrameStatus(void) const { return vbuffers.GetStatus(); }

    virtual void UpdatePauseFrame(void) = 0;

    void SetVideoResize(const QRect &videoRect);

    void SetVideoScalingAllowed(bool change); 

    bool IsVideoScalingAllowed(void) { return db_scaling_allowed; }

    virtual QRect GetPIPRect(int location, NuppelVideoPlayer *pipplayer = NULL);

    QString GetFilters(void) const;

  protected:
    void InitBuffers(int numdecode, bool extra_for_pause, int need_free,
                     int needprebuffer_normal, int needprebuffer_small,
                     int keepprebuffer);

    virtual void ShowPip(VideoFrame *frame, NuppelVideoPlayer *pipplayer);
    virtual int DisplayOSD(VideoFrame *frame, OSD *osd, int stride = -1, int revision = -1);

    virtual void SetPictureAttributeDBValue(
        PictureAttribute attributeType, int newValue);
    virtual QRect GetVisibleOSDBounds(float&, float&, float) const;
    virtual QRect GetTotalOSDBounds(void) const;

    static void CopyFrame(VideoFrame* to, const VideoFrame* from);

    void DoPipResize(int pipwidth, int pipheight);
    void ShutdownPipResize(void);

    void ResizeVideo(VideoFrame *frame);
    void DoVideoResize(const QSize &inDim, const QSize &outDim);
    virtual void ShutdownVideoResize(void);

    void SetVideoAspectRatio(float aspect);

    void ApplyManualScaleAndMove(void);
    void ApplyDBScaleAndMove(void);
    void ApplyLetterboxing(void);
    void ApplySnapToVideoRect(void);
    void PrintMoveResizeDebug(void);

    QSize   db_display_dim;   
    QPoint  db_move;          
    float   db_scale_horiz;   
    float   db_scale_vert;    
    PIPLocation db_pip_location;
    int     db_pip_size;      
    typedef QMap<PictureAttribute,int> PictureSettingMap;
    PictureSettingMap  db_pict_attr; 
    AspectOverrideMode db_aspectoverride;
    AdjustFillMode     db_adjustfill;
    LetterBoxColour    db_letterbox_colour;
    QString db_deint_filtername;
    bool    db_use_picture_controls;

    VideoDisplayProfile *db_vdisp_profile;

    // Manual Zoom
    float   mz_scale_v;       
    float   mz_scale_h;       
    QPoint  mz_move;          

    // Physical dimensions
    QSize   display_dim;      
    float   display_aspect;   

    // Video dimensions
    QSize   video_dim;        
    QSize   video_disp_dim;   
    float   video_aspect;     

    float   overriden_video_aspect;
    AspectOverrideMode aspectoverride;
    AdjustFillMode adjustfill;

    QRect   video_rect;
    QRect   display_video_rect;
    QRect   display_visible_rect;
    QRect   tmp_display_visible_rect;

    // Picture-in-Picture
    QSize   pip_desired_display_size;
    QSize   pip_display_size;
    QSize   pip_video_size;
    unsigned char      *pip_tmp_buf;
    ImgReSampleContext *pip_scaling_context;
    VideoFrame pip_tmp_image;

    // Video resizing (for ITV)
    bool    vsz_enabled;
    QRect   vsz_desired_display_rect;
    QSize   vsz_display_size;
    QSize   vsz_video_size;
    unsigned char      *vsz_tmp_buf;
    ImgReSampleContext *vsz_scale_context;

    // Deinterlacing
    bool           m_deinterlacing;
    QString        m_deintfiltername;
    FilterManager *m_deintFiltMan;
    FilterChain   *m_deintFilter;
    bool           m_deinterlaceBeforeOSD;

    VideoBuffers vbuffers;

    // Various state variables
    bool    embedding;
    bool    needrepaint;
    bool    allowpreviewepg;
    bool    errored;
    long long framesPlayed;
    bool    db_scaling_allowed; 
    PictureAttributeSupported supported_attributes;

    // Constants
    static const float kManualZoomMaxHorizontalZoom;
    static const float kManualZoomMaxVerticalZoom;
    static const float kManualZoomMinHorizontalZoom;
    static const float kManualZoomMinVerticalZoom;
    static const int   kManualZoomMaxMove;
};

#endif

---