Ticket #7067: mythtv7067.patch

File mythtv7067.patch, 12.1 KB (added by Davin McCall <davmac@…>, 9 years ago)

Updated patch, applies to current trunk (25150)

  • libs/libmythtv/vsync.cpp

     
    128128    m_delay(-1)
    129129{
    130130    bzero(&m_nexttrigger, sizeof(m_nexttrigger));
    131 
    132     int tolerance = m_refresh_interval / 200;
    133     if (m_interlaced && m_refresh_interval > ((m_frame_interval/2) + tolerance))
    134         m_interlaced = false; // can't display both fields at 2x rate
    135 
    136     //cout << "Frame interval: " << m_frame_interval << endl;
    137131}
    138132
    139133void VideoSync::Start(void)
     
    141135    gettimeofday(&m_nexttrigger, NULL); // now
    142136}
    143137
    144 /** \fn VideoSync::SetFrameInterval(int fr, bool intr)
    145  *  \brief Change frame interval and interlacing attributes
    146  */
    147 void VideoSync::SetFrameInterval(int fr, bool intr)
    148 {
    149     m_frame_interval = fr;
    150     m_interlaced = intr;
    151     int tolerance = m_refresh_interval / 200;
    152     if (m_interlaced && m_refresh_interval > ((m_frame_interval/2) + tolerance))
    153         m_interlaced = false; // can't display both fields at 2x rate
    154 
    155     VERBOSE(VB_PLAYBACK, LOC + QString("Set video sync frame interval to %1")
    156                                        .arg(m_frame_interval));
    157 }
    158 
    159138void VideoSync::OffsetTimeval(struct timeval& tv, int offset)
    160139{
    161140    tv.tv_usec += offset;
     
    171150    }
    172151}
    173152
    174 /** \fn VideoSync::UpdateNexttrigger()
    175  *  \brief Internal method to tells video synchronization method to use
    176  *         the next frame (or field, if interlaced) for CalcDelay()
    177  *         and WaitForFrame().
    178  */
    179 void VideoSync::UpdateNexttrigger()
    180 {
    181     // Offset by frame interval -- if interlaced, only delay by half
    182     // frame interval
    183     if (m_interlaced)
    184         OffsetTimeval(m_nexttrigger, m_frame_interval/2);
    185     else
    186         OffsetTimeval(m_nexttrigger, m_frame_interval);
    187 }
    188 
    189153/** \fn VideoSync::CalcDelay()
    190154 *  \brief Calculates the delay to the next frame.
    191155 *
     
    372336        //cerr << "Wait " << n << " intervals. Count " << blank.request.sequence;
    373337        //cerr  << " Delay " << m_delay << endl;
    374338    }
    375 }
    376339
    377 void DRMVideoSync::AdvanceTrigger(void)
    378 {
    379340    KeepPhase();
    380     UpdateNexttrigger();
    381341}
    382342#endif /* !_WIN32 */
    383343
     
    480440        m_context->WaitForVideoSync((n+1), (frameNum+n)%(n+1), &frameNum);
    481441        m_delay = CalcDelay();
    482442    }
    483 #endif /* USING_OPENGL_VSYNC */
    484 }
    485 
    486 void OpenGLVideoSync::AdvanceTrigger(void)
    487 {
    488 #ifdef USING_OPENGL_VSYNC
    489443
    490444    KeepPhase();
    491     UpdateNexttrigger();
    492445#endif /* USING_OPENGL_VSYNC */
    493446}
    494447#endif /* !_WIN32 */
     
    551504            usleep(m_delay);
    552505    }
    553506}
    554 
    555 void RTCVideoSync::AdvanceTrigger(void)
    556 {
    557     UpdateNexttrigger();
    558 }
    559507#endif /* __linux__ */
    560508
    561509#ifdef USING_VDPAU
     
    590538    VideoOutputVDPAU *vo = (VideoOutputVDPAU *)(m_video_output);
    591539    vo->SetNextFrameDisplayTimeOffset(m_delay);
    592540}
    593 
    594 void VDPAUVideoSync::AdvanceTrigger(void)
    595 {
    596     UpdateNexttrigger();
    597 }
    598 
    599541#endif
    600542
    601543BusyWaitVideoSync::BusyWaitVideoSync(VideoOutput *vo,
     
    646588    }
    647589}
    648590
    649 void BusyWaitVideoSync::AdvanceTrigger(void)
    650 {
    651     UpdateNexttrigger();
    652 }
    653 
    654591USleepVideoSync::USleepVideoSync(VideoOutput *vo,
    655592                                 int fr, int ri, bool intl) :
    656593    VideoSync(vo, fr, ri, intl)
     
    676613        usleep(m_delay);
    677614}
    678615
    679 void USleepVideoSync::AdvanceTrigger(void)
    680 {
    681     UpdateNexttrigger();
    682 }
  • libs/libmythtv/NuppelVideoPlayer.cpp

     
    704704     m_double_framerate = false;
    705705     m_double_process   = false;
    706706
    707      if (videosync)
    708          videosync->SetFrameInterval(frame_interval, false);
    709 
    710707     if (videoOutput)
    711708         videoOutput->FallbackDeint();
    712709}
     
    780777    if (interlaced && !m_deint_possible)
    781778    {
    782779        m_scan = scan;
    783         videosync->SetFrameInterval(frame_interval, false);
    784780        return;
    785781    }
    786782
     
    796792        if (videoOutput->NeedsDoubleFramerate())
    797793        {
    798794            m_double_framerate = true;
    799             videosync->SetFrameInterval(frame_interval, true);
    800             // Make sure video sync can double frame rate
    801             m_can_double = videosync->UsesFieldInterval();
     795            m_can_double = (frame_interval / 2 > videosync->getRefreshInterval() * 0.995);
    802796            if (!m_can_double)
    803797            {
    804798                VERBOSE(VB_IMPORTANT, LOC + "Video sync method can't support "
     
    815809        {
    816810            m_double_process = false;
    817811            m_double_framerate = false;
    818             videosync->SetFrameInterval(frame_interval, false);
    819812            videoOutput->SetDeinterlacingEnabled(false);
    820813            VERBOSE(VB_PLAYBACK, LOC + "Disabled deinterlacing");
    821814        }
     
    15711564void NuppelVideoPlayer::AVSync(bool limit_delay)
    15721565{
    15731566    float diverge = 0.0f;
     1567    int frameDelay = m_double_framerate ? frame_interval / 2 : frame_interval;
    15741568    // attempt to reduce fps for standalone PIP
    15751569    if (player_ctx->IsPIP() && framesPlayed % 2)
    15761570    {
    1577         videosync->WaitForFrame(avsync_adjustment);
    1578         videosync->AdvanceTrigger();
     1571        videosync->WaitForFrame(frameDelay + avsync_adjustment);
    15791572        if (!using_null_videoout)
    15801573            videoOutput->SetFramesPlayed(framesPlayed + 1);
    15811574        return;
     
    16061599    if (kScan_Detect == m_scan || kScan_Ignore == m_scan)
    16071600        ps = kScan_Progressive;
    16081601
    1609     bool dropframe = false;
    16101602    if (diverge < -MAXDIVERGE)
    16111603    {
    1612         dropframe = true;
    16131604        // If video is way behind of audio, adjust for it...
    16141605        QString dbg = QString("Video is %1 frames behind audio (too slow), ")
    16151606            .arg(-diverge);
     
    16431634
    16441635        VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, QString("AVSync waitforframe %1 %2")
    16451636                .arg(avsync_adjustment).arg(m_double_framerate));
    1646         videosync->WaitForFrame(avsync_adjustment + repeat_delay);
     1637        videosync->WaitForFrame(frameDelay + avsync_adjustment + repeat_delay);
    16471638        VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, "AVSync show");
    16481639        videoOutput->Show(ps);
    16491640
     
    16731664                videoOutput->PrepareFrame(buffer, ps, osd);
    16741665
    16751666            // Display the second field
    1676             videosync->AdvanceTrigger();
    1677             videosync->WaitForFrame(avsync_adjustment);
     1667            videosync->WaitForFrame(frameDelay + avsync_adjustment);
    16781668            videoOutput->Show(ps);
    16791669        }
    16801670
     
    16861676    }
    16871677    else
    16881678    {
    1689         videosync->WaitForFrame(0);
     1679        videosync->WaitForFrame(frameDelay);
    16901680    }
    16911681
    16921682    if (output_jmeter)
    16931683        output_jmeter->RecordCycleTime();
    16941684
    1695     if (!dropframe)
    1696         videosync->AdvanceTrigger();
    16971685    avsync_adjustment = 0;
    16981686
    16991687    if (diverge > MAXDIVERGE)
     
    17281716            prevtc = buffer->timecode;
    17291717            //cerr << delta << " ";
    17301718
     1719            avsync_delay = (buffer->timecode - currentaudiotime) * 1000;//usec
     1720            // prevents major jitter when pts resets during dvd title
     1721            if (avsync_delay > 2000000 && player_ctx->buffer->isDVD())
     1722                avsync_delay = 90000;
     1723            avsync_avg = (avsync_delay + (avsync_avg * 3)) / 4;
     1724
    17311725            // If the timecode is off by a frame (dropped frame) wait to sync
    17321726            if (delta > (int) frame_interval / 1200 &&
    17331727                delta < (int) frame_interval / 1000 * 3 &&
    17341728                prevrp == 0)
    17351729            {
    1736                 //cerr << "+ ";
    1737                 videosync->AdvanceTrigger();
    1738                 if (m_double_framerate)
    1739                     videosync->AdvanceTrigger();
     1730                // wait an extra frame interval
     1731                avsync_adjustment = frame_interval;
    17401732            }
    1741             prevrp = buffer->repeat_pict;
    1742 
    1743             avsync_delay = (buffer->timecode - currentaudiotime) * 1000;//usec
    1744             // prevents major jitter when pts resets during dvd title
    1745             if (avsync_delay > 2000000 && limit_delay)
    1746                 avsync_delay = 90000;
    1747             avsync_avg = (avsync_delay + (avsync_avg * 3)) / 4;
    17481733
    17491734            /* If the audio time codes and video diverge, shift
    17501735               the video by one interlaced field (1/2 frame) */
     
    19871972        // Make sure video sync can do it
    19881973        if (videosync != NULL && m_double_framerate)
    19891974        {
    1990             videosync->SetFrameInterval(frame_interval, m_double_framerate);
    1991             m_can_double = videosync->UsesFieldInterval();
     1975            m_can_double = (frame_interval / 2 > videosync->getRefreshInterval() * 0.995);
    19921976            if (!m_can_double)
    19931977            {
    19941978                VERBOSE(VB_IMPORTANT, "Video sync method can't support double "
     
    30072991
    30082992        m_double_framerate = videoOutput->NeedsDoubleFramerate();
    30092993        m_double_process = videoOutput->IsExtraProcessingRequired();
    3010         videosync->SetFrameInterval(frame_interval, m_double_framerate);
    30112994    }
    30122995
    30132996    if (normal_speed && audio.HasAudioOut())
  • libs/libmythtv/vsync.h

     
    3939 *   The factory method BestMethod tries subclasses in roughly quality
    4040 *   order until one succeeds.
    4141 *
    42  *   A/V sync methods may supply an additonal delay per frame. Other
     42 *   A/V sync methods may supply the nominal delay per frame. Other
    4343 *   than that, video timing is entirely up to these classes. When
    4444 *   WaitForFrame returns, it is time to show the frame.
    45  *
    46  *   There is some basic support for interlaced video timing where the
    47  *   fields need to be displayed sequentially. Passing true for the
    48  *   interlaced flags for the constructors, BestMethod, and
    49  *   SetFrameInterval will cause us to wait for half the specified frame
    50  *   interval, if the refresh rate is sufficient to do so.
    5145 */
    5246class VideoSync
    5347// virtual base class
     
    8074     */
    8175    virtual void WaitForFrame(int sync_delay) = 0;
    8276
    83     /// \brief Use the next frame or field for CalcDelay(void)
    84     ///        and WaitForFrame(int).
    85     virtual void AdvanceTrigger(void) = 0;
    86 
    87     void SetFrameInterval(int fi, bool interlaced);
    88 
    89     /// \brief Returns true AdvanceTrigger(void) advances a field at a time.
    90     bool UsesFieldInterval(void) const { return m_interlaced; }
    91     /// \brief Returns true AdvanceTrigger(void) advances a frame at a time.
    92     bool UsesFrameInterval(void) const { return !m_interlaced; }
     77    /// \brief Returns the (minimum) refresh interval of the output device.
     78    int getRefreshInterval(void) const { return m_refresh_interval; }
    9379
    9480    /** \brief Stops VSync; must be called from main thread.
    9581     *
     
    10591                                 bool interlaced);
    10692  protected:
    10793    static void OffsetTimeval(struct timeval& tv, int offset);
    108     void UpdateNexttrigger(void);
    10994    int CalcDelay(void);
    11095    void KeepPhase(void);
    11196
     
    137122    bool TryInit(void);
    138123    void Start(void);
    139124    void WaitForFrame(int sync_delay);
    140     void AdvanceTrigger(void);
    141125
    142126  private:
    143127    int m_dri_fd;
     
    179163    bool TryInit(void);
    180164    void Start(void);
    181165    void WaitForFrame(int sync_delay);
    182     void AdvanceTrigger(void);
    183166
    184167  private:
    185168    MythRenderOpenGL  *m_context;
     
    208191    QString getName(void) const { return QString("RTC"); }
    209192    bool TryInit(void);
    210193    void WaitForFrame(int sync_delay);
    211     void AdvanceTrigger(void);
    212194
    213195  private:
    214196    int m_rtcfd;
     
    229211    QString getName(void) const { return QString("VDPAU"); }
    230212    bool TryInit(void);
    231213    void WaitForFrame(int sync_delay);
    232     void AdvanceTrigger(void);
    233214
    234215  private:
    235216};
     
    257238    QString getName(void) const { return QString("USleep with busy wait"); }
    258239    bool TryInit(void);
    259240    void WaitForFrame(int sync_delay);
    260     void AdvanceTrigger(void);
    261241
    262242  private:
    263243    int m_cheat;
     
    285265    QString getName(void) const { return QString("USleep"); }
    286266    bool TryInit(void);
    287267    void WaitForFrame(int sync_delay);
    288     void AdvanceTrigger(void);
    289268};
    290269#endif /* VSYNC_H_INCLUDED */