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;

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 int WaitForFrame(int sync_delay) = 0;

    int getRefreshInterval(void) const { return m_refresh_interval; }
    void setRefreshInterval(int ri) { m_refresh_interval = ri; }

    virtual void setFrameInterval(int fi) { m_frame_interval = fi; };

    virtual void Stop(void) {}

    // documented in vsync.cpp
    static VideoSync *BestMethod(VideoOutput*,
                                 uint frame_interval, uint refresh_interval,
                                 bool interlaced);
  protected:
    int64_t GetTime(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;
    int64_t 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);
    int WaitForFrame(int sync_delay);

  private:
    int m_dri_fd;
    static const char *sm_dri_dev;
    
};
#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);
    int WaitForFrame(int sync_delay);

  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);
    int WaitForFrame(int sync_delay);

  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);
    int WaitForFrame(int sync_delay);
};

class DummyVideoSync : public VideoSync
{
  public:
    DummyVideoSync(VideoOutput* vo, int fr, int ri, bool intl)
     : VideoSync(vo, fr, ri, intl) { }
    ~DummyVideoSync() { }

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

---