smoother vsync with predictive frame skipping
From: Mark Spieth <mspieth@digivation.com.au>
---
mythtv/libs/libmythtv/mythplayer.cpp | 160 ++++++++++++++++++++++++++++------
mythtv/libs/libmythtv/mythplayer.h | 5 +
2 files changed, 135 insertions(+), 30 deletions(-)
diff --git a/mythtv/libs/libmythtv/mythplayer.cpp b/mythtv/libs/libmythtv/mythplayer.cpp
index 5368905..8d60f4c 100644
a
|
b
|
MythPlayer::MythPlayer(bool muted) |
236 | 236 | // Audio and video synchronization stuff |
237 | 237 | videosync(NULL), avsync_delay(0), |
238 | 238 | avsync_adjustment(0), avsync_avg(0), |
| 239 | avsync_predictor(0), avsync_predictor_enabled(false), |
239 | 240 | refreshrate(0), |
240 | 241 | lastsync(false), repeat_delay(0), |
241 | 242 | // Time Code stuff |
… |
… |
void MythPlayer::SetVideoParams(int width, int height, double fps, |
869 | 870 | video_frame_rate = fps; |
870 | 871 | float temp_speed = (play_speed == 0.0f) ? |
871 | 872 | audio.GetStretchFactor() : play_speed; |
872 | | frame_interval = (int)(1000000.0f / video_frame_rate / temp_speed); |
| 873 | SetFrameInterval(kScan_Progressive, 1.0 / (video_frame_rate * temp_speed)); |
873 | 874 | } |
874 | 875 | |
875 | 876 | if (videoOutput) |
… |
… |
int MythPlayer::NextCaptionTrack(int mode) |
1608 | 1609 | return NextCaptionTrack(nextmode); |
1609 | 1610 | } |
1610 | 1611 | |
| 1612 | void MythPlayer::SetFrameInterval(FrameScanType scan, double frame_period) |
| 1613 | { |
| 1614 | frame_interval = (int)(1000000.0f * frame_period + 0.5f); |
| 1615 | if (!avsync_predictor_enabled) |
| 1616 | avsync_predictor = 0; |
| 1617 | avsync_predictor_enabled = false; |
| 1618 | |
| 1619 | VERBOSE(VB_PLAYBACK, LOC + QString("SetFrameInterval ps:%1 scan:%2") |
| 1620 | .arg(play_speed).arg(scan) |
| 1621 | ); |
| 1622 | if (play_speed < 1 || play_speed > 2 || refreshrate <= 0) |
| 1623 | return; |
| 1624 | |
| 1625 | avsync_predictor_enabled = ((frame_interval-(frame_interval/200)) < refreshrate); |
| 1626 | } |
| 1627 | |
| 1628 | void MythPlayer::ResetAVSync(void) |
| 1629 | { |
| 1630 | avsync_avg = 0; |
| 1631 | if (!avsync_predictor_enabled || avsync_predictor >= refreshrate) |
| 1632 | avsync_predictor = 0; |
| 1633 | prevtc = 0; |
| 1634 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + "A/V sync reset"); |
| 1635 | } |
| 1636 | |
1611 | 1637 | void MythPlayer::InitAVSync(void) |
1612 | 1638 | { |
1613 | 1639 | videosync->Start(); |
… |
… |
void MythPlayer::InitAVSync(void) |
1631 | 1657 | .arg(1000000.0 / frame_interval, 0, 'f', 3); |
1632 | 1658 | VERBOSE(VB_PLAYBACK, LOC + msg); |
1633 | 1659 | |
| 1660 | SetFrameInterval(m_scan, 1.0 / (video_frame_rate * play_speed)); |
| 1661 | |
1634 | 1662 | // try to get preferential scheduling, but ignore if we fail to. |
1635 | 1663 | myth_nice(-19); |
1636 | 1664 | } |
1637 | 1665 | } |
1638 | 1666 | |
| 1667 | int64_t MythPlayer::AVSyncGetAudiotime(void) |
| 1668 | { |
| 1669 | int64_t currentaudiotime = 0; |
| 1670 | if (normal_speed) |
| 1671 | { |
| 1672 | currentaudiotime = audio.GetAudioTime(); |
| 1673 | } |
| 1674 | return currentaudiotime; |
| 1675 | } |
| 1676 | |
1639 | 1677 | #define MAXDIVERGE 3.0f |
1640 | 1678 | #define DIVERGELIMIT 30.0f |
1641 | 1679 | void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1642 | 1680 | { |
1643 | 1681 | int repeat_pict = 0; |
1644 | | int64_t timecode = audio.GetAudioTime(); |
| 1682 | int64_t timecode = 0; |
1645 | 1683 | |
1646 | 1684 | if (buffer) |
1647 | 1685 | { |
1648 | 1686 | repeat_pict = buffer->repeat_pict; |
1649 | 1687 | timecode = buffer->timecode; |
1650 | 1688 | } |
| 1689 | else |
| 1690 | timecode = audio.GetAudioTime(); |
1651 | 1691 | |
1652 | 1692 | float diverge = 0.0f; |
1653 | 1693 | int frameDelay = m_double_framerate ? frame_interval / 2 : frame_interval; |
| 1694 | int vsync_delay_clock = 0; |
| 1695 | int64_t currentaudiotime = 0; |
1654 | 1696 | |
1655 | 1697 | // attempt to reduce fps for standalone PIP |
1656 | 1698 | if (player_ctx->IsPIP() && framesPlayed % 2) |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1680 | 1722 | if (kScan_Detect == m_scan || kScan_Ignore == m_scan) |
1681 | 1723 | ps = kScan_Progressive; |
1682 | 1724 | |
| 1725 | bool dropframe = false; |
| 1726 | QString dbg; |
| 1727 | |
| 1728 | if (avsync_predictor_enabled) // && !prebuffering) |
| 1729 | { |
| 1730 | avsync_predictor += frame_interval; |
| 1731 | if (avsync_predictor >= refreshrate) |
| 1732 | { |
| 1733 | int refreshperiodsinframe = avsync_predictor/refreshrate; |
| 1734 | avsync_predictor -= refreshrate * refreshperiodsinframe; |
| 1735 | } |
| 1736 | else |
| 1737 | { |
| 1738 | dropframe = true; |
| 1739 | dbg = "A/V predict drop frame, "; |
| 1740 | } |
| 1741 | } |
| 1742 | |
1683 | 1743 | if (diverge < -MAXDIVERGE) |
1684 | 1744 | { |
| 1745 | dropframe = true; |
1685 | 1746 | // If video is way behind of audio, adjust for it... |
1686 | | QString dbg = QString("Video is %1 frames behind audio (too slow), ") |
| 1747 | dbg = QString("Video is %1 frames behind audio (too slow), ") |
1687 | 1748 | .arg(-diverge); |
| 1749 | } |
1688 | 1750 | |
| 1751 | if (dropframe) |
| 1752 | { |
1689 | 1753 | // Reset A/V Sync |
1690 | 1754 | lastsync = true; |
1691 | 1755 | |
| 1756 | currentaudiotime = AVSyncGetAudiotime(); |
1692 | 1757 | if (!using_null_videoout && |
1693 | 1758 | videoOutput->hasHWAcceleration() && |
1694 | 1759 | !videoOutput->IsSyncLocked()) |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1712 | 1777 | // if we get here, we're actually going to do video output |
1713 | 1778 | videoOutput->PrepareFrame(buffer, ps, osd); |
1714 | 1779 | |
1715 | | VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, QString("AVSync waitforframe %1 %2") |
| 1780 | VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, LOC + QString("AVSync waitforframe %1 %2") |
1716 | 1781 | .arg(avsync_adjustment).arg(m_double_framerate)); |
1717 | | videosync->WaitForFrame(frameDelay + avsync_adjustment + repeat_delay); |
1718 | | VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, "AVSync show"); |
| 1782 | vsync_delay_clock = videosync->WaitForFrame(frameDelay + avsync_adjustment + repeat_delay); |
| 1783 | currentaudiotime = AVSyncGetAudiotime(); |
| 1784 | VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, LOC + "AVSync show"); |
1719 | 1785 | videoOutput->Show(ps); |
1720 | 1786 | |
1721 | 1787 | if (videoOutput->IsErrored()) |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1743 | 1809 | videoOutput->PrepareFrame(buffer, ps, osd); |
1744 | 1810 | |
1745 | 1811 | // Display the second field |
1746 | | videosync->WaitForFrame(frameDelay + avsync_adjustment); |
| 1812 | //videosync->AdvanceTrigger(); |
| 1813 | vsync_delay_clock = videosync->WaitForFrame(frameDelay + avsync_adjustment); |
1747 | 1814 | videoOutput->Show(ps); |
1748 | 1815 | } |
1749 | 1816 | |
1750 | 1817 | repeat_delay = frame_interval * repeat_pict * 0.5; |
1751 | 1818 | |
1752 | 1819 | if (repeat_delay) |
1753 | | VERBOSE(VB_TIMESTAMP, QString("A/V repeat_pict, adding %1 repeat " |
| 1820 | VERBOSE(VB_TIMESTAMP, LOC + QString("A/V repeat_pict, adding %1 repeat " |
1754 | 1821 | "delay").arg(repeat_delay)); |
1755 | 1822 | } |
1756 | 1823 | else |
1757 | 1824 | { |
1758 | | videosync->WaitForFrame(frameDelay); |
| 1825 | vsync_delay_clock = videosync->WaitForFrame(frameDelay); |
| 1826 | currentaudiotime = AVSyncGetAudiotime(); |
1759 | 1827 | } |
1760 | 1828 | |
1761 | 1829 | if (output_jmeter) |
1762 | | output_jmeter->RecordCycleTime(); |
| 1830 | { |
| 1831 | if (output_jmeter->RecordCycleTime()) |
| 1832 | { |
| 1833 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + QString("A/V avsync_delay: %1, " |
| 1834 | "avsync_avg: %2") |
| 1835 | .arg(avsync_delay / 1000).arg(avsync_avg / 1000) |
| 1836 | ); |
| 1837 | } |
| 1838 | } |
1763 | 1839 | |
1764 | 1840 | avsync_adjustment = 0; |
1765 | 1841 | |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1767 | 1843 | { |
1768 | 1844 | // If audio is way behind of video, adjust for it... |
1769 | 1845 | // by cutting the frame rate in half for the length of this frame |
1770 | | avsync_adjustment = refreshrate; |
| 1846 | //avsync_adjustment = refreshrate; |
| 1847 | avsync_adjustment = frame_interval; |
1771 | 1848 | lastsync = true; |
1772 | 1849 | VERBOSE(VB_PLAYBACK, LOC + |
1773 | 1850 | QString("Video is %1 frames ahead of audio,\n" |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1776 | 1853 | |
1777 | 1854 | if (audio.HasAudioOut() && normal_speed) |
1778 | 1855 | { |
| 1856 | // must be sampled here due to Show delays |
1779 | 1857 | int64_t currentaudiotime = audio.GetAudioTime(); |
1780 | | VERBOSE(VB_TIMESTAMP, QString( |
| 1858 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + QString( |
1781 | 1859 | "A/V timecodes audio %1 video %2 frameinterval %3 " |
1782 | | "avdel %4 avg %5 tcoffset %6") |
| 1860 | "avdel %4 avg %5 tcoffset %6" |
| 1861 | " avp %7 avpen %8" |
| 1862 | " avdc %9" |
| 1863 | ) |
1783 | 1864 | .arg(currentaudiotime) |
1784 | 1865 | .arg(timecode) |
1785 | 1866 | .arg(frame_interval) |
1786 | | .arg(timecode - currentaudiotime) |
| 1867 | .arg(timecode - currentaudiotime - (int)(vsync_delay_clock*audio.GetStretchFactor()+500)/1000) |
1787 | 1868 | .arg(avsync_avg) |
1788 | 1869 | .arg(tc_wrap[TC_AUDIO]) |
| 1870 | .arg(avsync_predictor) |
| 1871 | .arg(avsync_predictor_enabled) |
| 1872 | .arg(vsync_delay_clock) |
1789 | 1873 | ); |
1790 | 1874 | if (currentaudiotime != 0 && timecode != 0) |
1791 | 1875 | { // currentaudiotime == 0 after a seek |
1792 | 1876 | // The time at the start of this frame (ie, now) is given by |
1793 | 1877 | // last->timecode |
1794 | | int delta = (int)((timecode - prevtc)/play_speed) - (frame_interval / 1000); |
1795 | | prevtc = timecode; |
1796 | | //cerr << delta << " "; |
1797 | | |
1798 | | // If the timecode is off by a frame (dropped frame) wait to sync |
1799 | | if (delta > (int) frame_interval / 1200 && |
1800 | | delta < (int) frame_interval / 1000 * 3 && |
1801 | | prevrp == 0) |
| 1878 | if (prevtc != 0) |
1802 | 1879 | { |
1803 | | // wait an extra frame interval |
1804 | | avsync_adjustment += frame_interval; |
| 1880 | int delta = (int)((timecode - prevtc)/play_speed) - (frame_interval / 1000); |
| 1881 | // If the timecode is off by a frame (dropped frame) wait to sync |
| 1882 | if (delta > (int) frame_interval / 1200 && |
| 1883 | delta < (int) frame_interval / 1000 * 3 && |
| 1884 | prevrp == 0) |
| 1885 | { |
| 1886 | // wait an extra frame interval |
| 1887 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + QString("A/V delay %1").arg(delta)); |
| 1888 | avsync_adjustment += frame_interval; |
| 1889 | //videosync->AdvanceTrigger(); |
| 1890 | //if (m_double_framerate) |
| 1891 | // videosync->AdvanceTrigger(); |
| 1892 | } |
1805 | 1893 | } |
| 1894 | prevtc = timecode; |
1806 | 1895 | prevrp = repeat_pict; |
1807 | 1896 | |
1808 | | avsync_delay = (timecode - currentaudiotime) * 1000;//usec |
| 1897 | avsync_delay = (timecode - currentaudiotime) * 1000 - (int)(vsync_delay_clock*audio.GetStretchFactor()); //usec |
1809 | 1898 | // prevents major jitter when pts resets during dvd title |
1810 | 1899 | if (avsync_delay > 2000000 && limit_delay) |
1811 | 1900 | avsync_delay = 90000; |
1812 | 1901 | avsync_avg = (avsync_delay + (avsync_avg * 3)) / 4; |
1813 | 1902 | |
| 1903 | int avsync_used = avsync_avg; |
| 1904 | if (labs(avsync_used) > labs(avsync_delay)) |
| 1905 | avsync_used = avsync_delay; |
| 1906 | |
1814 | 1907 | /* If the audio time codes and video diverge, shift |
1815 | 1908 | the video by one interlaced field (1/2 frame) */ |
1816 | 1909 | if (!lastsync) |
1817 | 1910 | { |
1818 | | if (avsync_avg > frame_interval * 3 / 2) |
| 1911 | if (avsync_used > refreshrate) |
1819 | 1912 | { |
1820 | 1913 | avsync_adjustment += refreshrate; |
1821 | | lastsync = true; |
| 1914 | //lastsync = true; |
| 1915 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + "A/V avg high extend"); |
1822 | 1916 | } |
1823 | | else if (avsync_avg < 0 - frame_interval * 3 / 2) |
| 1917 | else if (avsync_used < 0 - refreshrate) |
1824 | 1918 | { |
1825 | 1919 | avsync_adjustment -= refreshrate; |
1826 | | lastsync = true; |
| 1920 | //lastsync = true; |
| 1921 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + "A/V avg high skip"); |
1827 | 1922 | } |
1828 | 1923 | } |
1829 | 1924 | else |
… |
… |
void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay) |
1831 | 1926 | } |
1832 | 1927 | else |
1833 | 1928 | { |
1834 | | avsync_avg = 0; |
| 1929 | ResetAVSync(); |
1835 | 1930 | } |
1836 | 1931 | } |
| 1932 | else |
| 1933 | { |
| 1934 | VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC + QString("A/V no sync proc ns:%1").arg(normal_speed)); |
| 1935 | } |
1837 | 1936 | } |
1838 | 1937 | |
1839 | 1938 | void MythPlayer::DisplayPauseFrame(void) |
… |
… |
void MythPlayer::ClearAfterSeek(bool clearvideobuffers) |
3437 | 3536 | commBreakMap.SetTracker(framesPlayed); |
3438 | 3537 | commBreakMap.ResetLastSkip(); |
3439 | 3538 | needNewPauseFrame = true; |
| 3539 | ResetAVSync(); |
3440 | 3540 | } |
3441 | 3541 | |
3442 | 3542 | void MythPlayer::SetPlayerInfo(TV *tv, QWidget *widget, |
diff --git a/mythtv/libs/libmythtv/mythplayer.h b/mythtv/libs/libmythtv/mythplayer.h
index 95a4883..88d4d79 100644
a
|
b
|
class MPUBLIC MythPlayer |
509 | 509 | void WrapTimecode(int64_t &timecode, TCTypes tc_type); |
510 | 510 | void InitAVSync(void); |
511 | 511 | virtual void AVSync(VideoFrame *buffer, bool limit_delay = false); |
| 512 | void ResetAVSync(void); |
| 513 | int64_t AVSyncGetAudiotime(void); |
| 514 | void SetFrameInterval(FrameScanType scan, double speed); |
512 | 515 | void FallbackDeint(void); |
513 | 516 | void CheckExtraAudioDecode(void); |
514 | 517 | |
… |
… |
class MPUBLIC MythPlayer |
694 | 697 | int avsync_delay; |
695 | 698 | int avsync_adjustment; |
696 | 699 | int avsync_avg; |
| 700 | int avsync_predictor; |
| 701 | bool avsync_predictor_enabled; |
697 | 702 | int refreshrate; |
698 | 703 | bool lastsync; |
699 | 704 | bool decode_extra_audio; |