videooutbase.h

Go to the documentation of this file.

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

#ifndef VIDEOOUTBASE_H_
#define VIDEOOUTBASE_H_

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

#include <QSize>
#include <QRect>
#include <QString>
#include <QPoint>
#include <QMap>
#include <qwindowdefs.h>

#include "videobuffers.h"
#include "mythcodecid.h"
#include "videoouttypes.h"
#include "videooutwindow.h"
#include "mythdisplay.h"
#include "DisplayRes.h"
#include "videodisplayprofile.h"
#include "videocolourspace.h"
#include "visualisations/videovisual.h"

using namespace std;

class MythPainter;
class MythYUVAPainter;
class MythImage;
class MythPlayer;
class OSD;
class FilterChain;
class FilterManager;
class AudioPlayer;
class MythRender;

typedef QMap<MythPlayer*,PIPLocation> PIPMap;

extern "C" {
struct ImgReSampleContext;
struct SwsContext;
}

class VideoOutput
{
  public:
    static void GetRenderOptions(render_opts &opts);
    static VideoOutput *Create(
        const QString &decoder, MythCodecID  codec_id,     void *codec_priv,
        PIPState pipState,      const QSize &video_dim,    float video_aspect,
        QWidget *parentwidget,  const QRect &embed_rect,   float video_prate,
        uint playerFlags);

    VideoOutput();
    virtual ~VideoOutput();

    virtual bool Init(int width, int height, float aspect,
                      WId winid, const QRect &win_rect, MythCodecID codec_id);
    virtual void InitOSD(OSD *osd);
    virtual void SetVideoFrameRate(float);
    virtual bool IsPreferredRenderer(QSize video_size);
    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;
    void         GetDeinterlacers(QStringList &deinterlacers);
    QString      GetDeinterlacer(void);
    virtual void PrepareFrame(VideoFrame *buffer, FrameScanType,
                              OSD *osd) = 0;
    virtual void Show(FrameScanType) = 0;

    virtual void WindowResized(const QSize &new_size) {}

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

    virtual void ResizeDisplayWindow(const QRect&, bool);
    virtual void EmbedInWidget(const QRect &rect);
    virtual void StopEmbedding(void);
    virtual void ResizeForGui(void);
    virtual void ResizeForVideo(uint width = 0, uint height = 0);
    virtual void MoveResizeWindow(QRect new_rect) = 0;

    virtual void MoveResize(void);
    virtual void Zoom(ZoomDirection direction);

    virtual void GetOSDBounds(QRect &total, QRect &visible,
                              float &visibleAspect, float &fontScale,
                              float themeAspect) const;
    QRect        GetMHEGBounds(void);
    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;

    AspectOverrideMode GetAspectOverride(void) const;
    virtual void ToggleAspectOverride(
        AspectOverrideMode aspectOverrideMode = kAspect_Toggle);

    AdjustFillMode GetAdjustFill(void) const;
    virtual 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,
                              const PIPMap &pipPlayers,
                              FrameScanType scan = kScan_Ignore) = 0;

    void ExposeEvent(void);

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

    bool AllowPreviewEPG(void) const;

    virtual bool IsPIPSupported(void) const { return false; }
    virtual bool IsPBPSupported(void) const { return false; }
    virtual bool NeedExtraAudioDecode(void) const { return false; }

    virtual bool hasHWAcceleration(void) const { return false; }
    virtual void* GetDecoderContext(unsigned char* buf, uint8_t*& id) { return NULL; }

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

    bool IsErrored() const { return errorState != kError_None; }
    VideoErrorState GetError(void) const { return errorState; }
    // Video Buffer Management
    void SetPrebuffering(bool normal) { vbuffers.SetPrebuffering(normal); }
    virtual void ClearAfterSeek(void) { vbuffers.ClearAfterSeek(); }

    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);

    virtual VideoFrame *GetNextFreeFrame(void)
        { return vbuffers.GetNextFreeFrame(); }
    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(VideoFrame *frame)
        { vbuffers.DoneDisplayingFrame(frame); }
    virtual void DiscardFrame(VideoFrame *frame) { vbuffers.DiscardFrame(frame); }
    virtual void DiscardFrames(bool kf) { vbuffers.DiscardFrames(kf); }
    virtual void ClearDummyFrame(VideoFrame* frame);
    virtual void CheckFrameStates(void) { }

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

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

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

    virtual void UpdatePauseFrame(int64_t &disp_timecode) = 0;

    void SetVideoResize(const QRect &videoRect);

    void SetVideoScalingAllowed(bool change);

    bool IsVideoScalingAllowed(void) const;

    virtual QRect GetPIPRect(PIPLocation location,
                             MythPlayer *pipplayer = NULL,
                             bool do_pixel_adj = true) const;
    virtual void RemovePIP(MythPlayer *pipplayer) { }

    virtual void SetPIPState(PIPState setting);

    virtual QString GetOSDRenderer(void) const;
    virtual MythPainter *GetOSDPainter(void) { return (MythPainter*)osd_painter; }
    virtual bool GetScreenShot(int width = 0, int height = 0,
                               QString filename = "") { return false; }

    QString GetFilters(void) const;
    QRect   GetImageRect(const QRect &rect, QRect *display = NULL);
    QRect   GetSafeRect(void);

    // Visualisations
    bool EnableVisualisation(AudioPlayer *audio, bool enable,
                             const QString &name = QString(""));
    virtual bool CanVisualise(AudioPlayer *audio, MythRender *render);
    virtual bool SetupVisualisation(AudioPlayer *audio, MythRender *render,
                                    const QString &name);
    VideoVisual* GetVisualisation(void) { return m_visual; }
    QString GetVisualiserName(void);
    virtual QStringList GetVisualiserList(void);
    void DestroyVisualisation(void);

    // Hue adjustment for certain vendors (mostly ATI)
    static int CalcHueBase(const QString &adaptor_name);

    // 3D TV
    virtual bool StereoscopicModesAllowed(void) const { return false; }
    void SetStereoscopicMode(StereoscopicMode mode) { m_stereo = mode; }
    StereoscopicMode GetStereoscopicMode(void) const { return m_stereo; }

  protected:
    void InitBuffers(int numdecode, bool extra_for_pause, int need_free,
                     int needprebuffer_normal, int needprebuffer_small,
                     int keepprebuffer);
    void InitDisplayMeasurements(uint width, uint height, bool resize);
    virtual void ShowPIPs(VideoFrame *frame, const PIPMap &pipPlayers);
    virtual void ShowPIP(VideoFrame        *frame,
                         MythPlayer *pipplayer,
                         PIPLocation        loc);

    virtual bool DisplayOSD(VideoFrame *frame, OSD *osd);

    QRect GetVisibleOSDBounds(float&, float&, float) const;
    QRect GetTotalOSDBounds(void) const;
    virtual bool hasFullScreenOSD(void) const { return false; }

    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);

    VideoOutWindow     window;
    QSize              db_display_dim;   
    VideoColourSpace   videoColourSpace;
    AspectOverrideMode db_aspectoverride;
    AdjustFillMode     db_adjustfill;
    LetterBoxColour    db_letterbox_colour;
    QString            db_deint_filtername;

    // Video parameters
    MythCodecID          video_codec_id;
    VideoDisplayProfile *db_vdisp_profile;

    // Picture-in-Picture
    QSize   pip_desired_display_size;
    QSize   pip_display_size;
    QSize   pip_video_size;
    unsigned char      *pip_tmp_buf;
    unsigned char      *pip_tmp_buf2;
    struct SwsContext  *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;
    struct SwsContext  *vsz_scale_context;

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

    VideoBuffers vbuffers;

    // Various state variables
    VideoErrorState errorState;
    long long framesPlayed;

    // Custom display resolutions
    DisplayRes *display_res;

    // Display information
    QSize monitor_sz;
    QSize monitor_dim;

    // OSD painter and surface
    MythYUVAPainter *osd_painter;
    MythImage       *osd_image;

    // Visualisation
    VideoVisual     *m_visual;

    // 3D TV mode
    StereoscopicMode m_stereo;
};

#endif