vsync.h

Go to the documentation of this file.

/*
 * Copyright (c) 2004 Doug Larrick <doug@ties.org>.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef VSYNC_H_INCLUDED
#define VSYNC_H_INCLUDED

#include <sys/time.h>
#include <time.h>

class VideoOutput;

typedef unsigned long GLXDrawable;
#ifdef USING_OPENGL
typedef struct __GLXcontextRec *GLXContext;
#else
typedef void *GLXContext;
#endif

extern bool tryingVideoSync;

class VideoSync
// virtual base class
{
  public:
    VideoSync(VideoOutput*, int fi, int ri, bool intr);
    virtual ~VideoSync() {}

    virtual QString getName(void) const = 0;
    virtual bool TryInit(void) = 0;

    virtual void Start(void);

    virtual void WaitForFrame(int sync_delay) = 0;

    virtual void AdvanceTrigger(void) = 0;

    void SetFrameInterval(int fi, bool interlaced);

    bool UsesFieldInterval(void) const { return m_interlaced; }
    bool UsesFrameInterval(void) const { return !m_interlaced; }

    virtual void Stop(void) {}

    // documented in vsync.cpp
    static VideoSync *BestMethod(VideoOutput*,
                                 uint frame_interval, uint refresh_interval,
                                 bool interlaced);
  protected:
    static void OffsetTimeval(struct timeval& tv, int offset);
    void UpdateNexttrigger(void);
    int CalcDelay(void);
    void KeepPhase(void);

    VideoOutput *m_video_output;
    int m_frame_interval; // of video
    int m_refresh_interval; // of display
    bool m_interlaced;
    struct timeval m_nexttrigger;
    int m_delay;
    
    static int m_forceskip;
};

#ifndef _WIN32

class DRMVideoSync : public VideoSync
{
  public:
    DRMVideoSync(VideoOutput*,
                 int frame_interval, int refresh_interval, bool interlaced);
    ~DRMVideoSync();

    QString getName(void) const { return QString("DRM"); }
    bool TryInit(void);
    void Start(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);

  private:
    int m_dri_fd;
    static char *sm_dri_dev;
    
};
#endif // !_WIN32

#ifndef _WIN32

class nVidiaVideoSync : public VideoSync
{
  public:
    nVidiaVideoSync(VideoOutput*,
                    int frame_interval, int refresh_interval, bool interlaced);
    ~nVidiaVideoSync();

    QString getName(void) const { return QString("nVidia polling"); }
    bool TryInit(void);
    void Start(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);

  private:
    bool dopoll(void) const;
    int m_nvidia_fd;
    static char *sm_nvidia_dev;
};
#endif // !_WIN32

#ifndef _WIN32

class OpenGLVideoSync : public VideoSync
{
  public:
    OpenGLVideoSync(VideoOutput*,
                    int frame_interval, int refresh_interval, bool interlaced);
    ~OpenGLVideoSync();

    QString getName(void) const { return QString("SGI OpenGL"); }
    bool TryInit(void);
    void Start(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);

  private:
    GLXDrawable m_drawable;
    GLXContext  m_context;

  private:
    QMutex      m_lock;
};
#endif // !_WIN32

#ifdef __linux__

class RTCVideoSync : public VideoSync
{
  public:
    RTCVideoSync(VideoOutput*,
                 int frame_interval, int refresh_interval, bool interlaced);
    ~RTCVideoSync();

    QString getName(void) const { return QString("RTC"); }
    bool TryInit(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);

  private:
    int m_rtcfd;
};
#endif

class BusyWaitVideoSync : public VideoSync
{
  public:
    BusyWaitVideoSync(VideoOutput*,
                      int frame_interval, int refresh_interval, 
                      bool interlaced);
    ~BusyWaitVideoSync();

    QString getName(void) const { return QString("USleep with busy wait"); }
    bool TryInit(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);

  private:
    int m_cheat;
    int m_fudge;
};

class USleepVideoSync : public VideoSync
{
  public:
    USleepVideoSync(VideoOutput*,
                    int frame_interval, int refresh_interval, 
                    bool interlaced);
    ~USleepVideoSync();

    QString getName(void) const { return QString("USleep"); }
    bool TryInit(void);
    void WaitForFrame(int sync_delay);
    void AdvanceTrigger(void);
};
#endif /* VSYNC_H_INCLUDED */

---