Fix interlacing detection.

AutoDeint() was using m_scan_locked to lock in the current detected
interlaced vs progressive detection which totally broke it's intended
functionality, on top of that the MythDVDPlayer had disabled this
broken-ness but only for DVD's. Also the comments said that
progressive video would be detected on the first progressive frame,
but that wasn't the case. The m_scan_locked hack was further broken
by some threading changes so it didn't even work as a hack anymore.

Anyway this was a mess so I've just rewritten the AutoDeint code.
Now AutoDeint() tracks the last 30 frames and if any of them are
interlaced we decide that the video is interlaced and conversely
if all are progressive we decide the video is progressive. Thirty
frames is very arbritary, generally three would be enough as it
would account for 3-2 pulldown and all variations there of. But
Video that is progressive and accidentally deinterlaced looks a
lot better than video that is interlaced and not deinterlaced for
progressive display.

I've also added a small hack for NTSC and PAL video, if the number
of lines in the video is 480 or 576 we assume the video is interlaced.
After watching a poorly mastered DVD one too many times I decided
this hack was necessary. The DVD override for still frames will
still ensure that those are not deinterlaced, this is just for the
autodetection in the video.

Author: daniel-kristjansson

mythtv/libs/libmythtv/mythbdplayer.cpp

@@ -44,7 +44,7 @@ void MythBDPlayer::DisplayPauseFrame(void)
     if (player_ctx->buffer->IsBD() &&
         player_ctx->buffer->BD()->IsInStillFrame())
     {
-        SetScanType(kScan_Progressive);
+        SetScanType(kScan_Progressive, false);
     }
     DisplayMenu();
     MythPlayer::DisplayPauseFrame();

mythtv/libs/libmythtv/mythdvdplayer.cpp

@@ -16,11 +16,6 @@ MythDVDPlayer::MythDVDPlayer(bool muted)
 {
 }
 
-void MythDVDPlayer::AutoDeint(VideoFrame *frame, bool allow_lock)
-{
-    MythPlayer::AutoDeint(frame, false);
-}
-
 void MythDVDPlayer::ReleaseNextVideoFrame(VideoFrame *buffer,
                                           int64_t timecode, bool wrap)
 {
@@ -48,7 +43,7 @@ void MythDVDPlayer::DisplayPauseFrame(void)
     if (player_ctx->buffer->IsDVD() &&
         player_ctx->buffer->DVD()->IsInStillFrame())
     {
-        SetScanType(kScan_Progressive);
+        SetScanType(kScan_Progressive, false);
     }
     DisplayDVDButton();
     MythPlayer::DisplayPauseFrame();

mythtv/libs/libmythtv/mythdvdplayer.h

@@ -69,9 +69,6 @@ class MythDVDPlayer : public MythPlayer
     virtual void SeekForScreenGrab(uint64_t &number, uint64_t frameNum,
                                    bool absolute);
 
-    // Private initialization stuff
-    virtual void AutoDeint(VideoFrame* frame, bool allow_lock = true);
-
     // Complicated gets
     virtual long long CalcMaxFFTime(long long ff, bool setjump = true) const;
     virtual void calcSliderPos(osdInfo &info, bool paddedFields = false);

mythtv/libs/libmythtv/mythplayer.cpp

@@ -154,8 +154,10 @@ MythPlayer::MythPlayer(bool muted)
       video_disp_dim(0,0), video_dim(0,0),
       video_frame_rate(29.97f), video_aspect(4.0f / 3.0f),
       forced_video_aspect(-1),
-      resetScan(kScan_Ignore), m_scan(kScan_Interlaced),
-      m_scan_locked(false), m_scan_tracker(0), m_scan_initialized(false),
+      resetScanType(kScan_Ignore), resetScanAllowLock(false),
+      m_scan(kScan_Interlaced),
+      m_scan_locked(false), m_scan_tracker_index(0),
+      m_scan_initialized(false),
       keyframedist(30),
       // Prebuffering
       buffering(false),
@@ -669,6 +671,12 @@ FrameScanType MythPlayer::detectInterlace(FrameScanType newScan,
             scan = newScan;
     };
 
+    // Almost all NTSC/PAL sized frames we'll ever see will be interlaced
+    // even if the frames are marked as progressive, so detect those as
+    // being interlaced.
+    if ((480 == video_height || 576 == video_height) && fps <= 30)
+        scan = kScan_Interlaced;
+
     LOG(VB_PLAYBACK, LOG_INFO, LOC + dbg+toQString(scan));
 
     return scan;
@@ -691,76 +699,66 @@ void MythPlayer::FallbackDeint(void)
          videoOutput->FallbackDeint();
 }
 
-void MythPlayer::AutoDeint(VideoFrame *frame, bool allow_lock)
+void MythPlayer::AutoDeint(VideoFrame *frame)
 {
     if (!frame || m_scan_locked)
         return;
 
-    if (frame->interlaced_frame)
+    // Almost all NTSC/PAL sized frames we'll ever see will be interlaced
+    // even if the frames are marked as progressive, so detect those as
+    // being interlaced.
+    if (frame->height == 480 || frame->height == 576)
+        frame->interlaced_frame = 1;
+
+    const static int kScanTrackerSize = 30;
+    bool iframe = bool(frame->interlaced_frame);
+    if (m_scan_tracker.size() < kScanTrackerSize)
     {
-        if (m_scan_tracker < 0)
-        {
-            LOG(VB_PLAYBACK, LOG_INFO, LOC +
-                QString("interlaced frame seen after %1 progressive frames")
-                    .arg(abs(m_scan_tracker)));
-            m_scan_tracker = 2;
-            if (allow_lock)
-            {
-                LOG(VB_PLAYBACK, LOG_INFO, LOC + "Locking scan to Interlaced.");
-                SetScanType(kScan_Interlaced);
-                return;
-            }
-        }
-        m_scan_tracker++;
+        m_scan_tracker.push_back(iframe);
     }
     else
     {
-        if (m_scan_tracker > 0)
-        {
-            LOG(VB_PLAYBACK, LOG_INFO, LOC +
-                QString("progressive frame seen after %1 interlaced frames")
-                    .arg(m_scan_tracker));
-            m_scan_tracker = 0;
-        }
-        m_scan_tracker--;
+        m_scan_tracker_index %= kScanTrackerSize;
+        m_scan_tracker[m_scan_tracker_index] = iframe;
+        m_scan_tracker_index++;
     }
 
-    if ((m_scan_tracker % 400) == 0)
+    FrameScanType scan = (iframe) ? kScan_Interlaced : kScan_Progressive;
+    if (m_scan != scan)
     {
-        QString type = (m_scan_tracker < 0) ? "progressive" : "interlaced";
-        LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("%1 %2 frames seen.")
-                .arg(abs(m_scan_tracker)).arg(type));
+        for (int i = 0; scan == kScan_Progressive &&
+                 i < m_scan_tracker.size(); i++)
+            scan = (m_scan_tracker[i]) ? kScan_Interlaced : kScan_Progressive;
+        SetScanType(scan, false);
     }
-
-    int min_count = !allow_lock ? 0 : 2;
-    if (abs(m_scan_tracker) <= min_count)
-        return;
-
-    SetScanType((m_scan_tracker > min_count) ? kScan_Interlaced : kScan_Progressive);
-    m_scan_locked  = false;
 }
 
-void MythPlayer::SetScanType(FrameScanType scan)
+void MythPlayer::SetScanType(FrameScanType scan, bool allow_lock)
 {
     QMutexLocker locker(&videofiltersLock);
 
     if (!is_current_thread(playerThread))
     {
-        resetScan = scan;
+        resetScanType = scan;
+        resetScanAllowLock = allow_lock;
         return;
     }
 
     if (!videoOutput || !videosync)
         return; // hopefully this will be called again later...
 
-    resetScan = kScan_Ignore;
+    resetScanType = kScan_Ignore;
 
     if (m_scan_initialized &&
         m_scan == scan &&
         m_frame_interval == frame_interval)
         return;
 
-    m_scan_locked = (scan != kScan_Detect);
+    LOG(VB_PLAYBACK, LOG_INFO,
+        QString("SetScanType(%1, allow_lock %2)")
+        .arg(scan).arg(allow_lock));
+
+    m_scan_locked = allow_lock && (scan != kScan_Detect);
 
     m_scan_initialized = true;
     m_frame_interval = frame_interval;
@@ -833,10 +831,9 @@ void MythPlayer::SetVideoParams(int width, int height, double fps,
     if (IsErrored())
         return;
 
+    m_scan_tracker.clear();
     SetScanType(detectInterlace(scan, m_scan, video_frame_rate,
-                                video_disp_dim.height()));
-    m_scan_locked  = false;
-    m_scan_tracker = (m_scan == kScan_Interlaced) ? 2 : 0;
+                                video_disp_dim.height()), false);
 }
 
 void MythPlayer::SetFileLength(int total, int frames)
@@ -2153,12 +2150,10 @@ void MythPlayer::VideoStart(void)
 
     // Default to Interlaced playback to allocate the deinterlacer structures
     // Enable autodetection of interlaced/progressive from video stream
-    // And initialoze m_scan_tracker to 2 which will immediately switch to
-    // progressive if the first frame is progressive in AutoDeint().
     m_scan             = kScan_Interlaced;
     m_scan_locked      = false;
     m_double_framerate = false;
-    m_scan_tracker     = 2;
+    m_scan_tracker.clear();
 
     if (player_ctx->IsPIP() && using_null_videoout)
     {
@@ -2571,8 +2566,8 @@ void MythPlayer::EventLoop(void)
         SetCaptionsEnabled(false, false);
 
     // reset the scan (and hence deinterlacers) if triggered by the decoder
-    if (resetScan != kScan_Ignore)
-        SetScanType(resetScan);
+    if (resetScanType != kScan_Ignore)
+        SetScanType(resetScanType, resetScanAllowLock);
 
     // refresh the position map for an in-progress recording while editing
     if (hasFullPositionMap && watchingrecording && player_ctx->recorder &&

mythtv/libs/libmythtv/mythplayer.h

@@ -314,7 +314,7 @@ class MTV_PUBLIC MythPlayer
     void DisableHardwareDecoders(void)        { no_hardware_decoders = true; }
     void NextScanType(void)
         { SetScanType((FrameScanType)(((int)m_scan + 1) & 0x3)); }
-    void SetScanType(FrameScanType);
+    void SetScanType(FrameScanType, bool allow_lock = true);
     FrameScanType GetScanType(void) const { return m_scan; }
     bool IsScanTypeLocked(void) const { return m_scan_locked; }
     void Zoom(ZoomDirection direction);
@@ -461,7 +461,7 @@ class MTV_PUBLIC MythPlayer
     void InitFilters(void);
     FrameScanType detectInterlace(FrameScanType newScan, FrameScanType scan,
                                   float fps, int video_height);
-    virtual void AutoDeint(VideoFrame* frame, bool allow_lock = true);
+    void AutoDeint(VideoFrame*);
 
     // Private Sets
     void SetPlayingInfo(const ProgramInfo &pginfo);
@@ -614,13 +614,16 @@ class MTV_PUBLIC MythPlayer
     float    video_aspect;    ///< Video (input) Apect Ratio
     float    forced_video_aspect;
     /// Tell the player thread to set the scan type (and hence deinterlacers)
-    FrameScanType resetScan;
+    FrameScanType resetScanType;
+    bool          resetScanAllowLock;
     /// Video (input) Scan Type (interlaced, progressive, detect, ignore...)
     FrameScanType m_scan;
     /// Set when the user selects a scan type, overriding the detected one
     bool     m_scan_locked;
+    /// Index into m_scan_tracker
+    int      m_scan_tracker_index;
     /// Used for tracking of scan type for auto-detection of interlacing
-    int      m_scan_tracker;
+    QList<bool> m_scan_tracker;
     /// Set when SetScanType runs the first time
     bool     m_scan_initialized;
     /// Video (input) Number of frames between key frames (often inaccurate)