Ticket #4872: detectLetterboxV8.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -294 +294 @@
     text_size = 8 * (sizeof(teletextsubtitle) + VT_WIDTH);
     for (int i = 0; i < MAXTBUFFER; i++)
         txtbuffers[i].buffer = new unsigned char[text_size + 1];
+    
+    int dbAdjustFill = gContext->GetNumSetting("AdjustFill", 0);
+    isDetectLetterbox = dbAdjustFill >= kAdjustFill_AutoDetect_DefaultOff;
+    detectLetterboxDefaultMode = (AdjustFillMode) max((int) kAdjustFill_Off, 
+                                 dbAdjustFill - kAdjustFill_AutoDetect_DefaultOff);
+    detectLetterboxSwitchFrame = -1;
+    detectLetterboxPossibleHalfFrame = -1;
+    detectLetterboxPossibleFullFrame = -1;
+    detectLetterboxDetectedMode = GetAdjustFill();
+    detectLetterboxLimit = gContext->GetNumSetting("DetectLeterboxLimit", 75);
 }
 
 NuppelVideoPlayer::~NuppelVideoPlayer(void)
@@ -1405 +1415 @@
     buffer->timecode = timecode;
 
     videoOutput->ReleaseFrame(buffer);
+
+    if (isDetectLetterbox)
+        DetectLetterbox(buffer);
 }
 
 /** \fn NuppelVideoPlayer::DiscardVideoFrame(VideoFrame*)
@@ -2739 +2752 @@
     return true;
 }
 
+/** \fn NuppelVideoPlayer::DetectLetterbox(VideoFrame*)
+ *  \brief Detects if this frame is or is not letterboxed 
+ * 
+ *  If a change is detected detectLetterboxSwitchFrame and 
+ *  detectLetterboxDetectedMode are set.
+ */
+void NuppelVideoPlayer::DetectLetterbox(VideoFrame *frame)
+{
+    const unsigned char *buf = frame->buf; 
+    const int width = frame->width;
+    const int height = frame->height;
+    const int *pitches = frame->pitches;
+    const int *offsets = frame->offsets;
+    const long long frameNumber = frame->frameNumber;
+
+    const int NUMBER_OF_DETECTION_LINES = 3; // How many lines are we looking at
+    const int THRESHOLD = 5; // Y component has to not vary more than this in the bars
+    const int HORIZONTAL_THRESHOLD = 4; // How tolerant are we that the image has horizontal edges
+
+    // If the black bars is larger than this limit we switch to Half or Full Mode
+    //    const int fullLimit = (int) (((height - width * 9 / 16) / 2) * detectLetterboxLimit / 100);
+    //    const int halfLimit = (int) (((height - width * 9 / 14) / 2) * detectLetterboxLimit / 100);
+    // If the black bars is larger than this limit we switch to Half or Full Mode
+    const int fullLimit = (int) ((height * (1 - video_aspect * 9 / 16) / 2) * detectLetterboxLimit / 100);
+    const int halfLimit = (int) ((height * (1 - video_aspect * 9 / 14) / 2) * detectLetterboxLimit / 100);
+
+
+    const int xPos[] = {width / 4, width / 2, width * 3 / 4};    // Lines to scan for black letterbox edge
+    int topHits = 0, bottomHits = 0, minTop = 0, minBottom = 0, maxTop = 0, maxBottom = 0;
+    int topHit[] = {0, 0, 0}, bottomHit[] = {0, 0, 0};
+
+    if (!videoOutput)
+        return;
+
+    
+    if (frame->codec != FMT_YV12)
+    {
+        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is not in YV12 (was %1)").arg(frame->codec));
+        isDetectLetterbox = false;
+        return;
+    }
+
+    if (frameNumber < 0)
+    {
+        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Strange frame number %1").arg(frameNumber));
+        return;
+    }
+
+    if (video_aspect > 1.5) 
+    {
+        if (detectLetterboxDetectedMode != detectLetterboxDefaultMode)
+        {
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is already in widescreen (aspect: %1)").arg(video_aspect));
+            detectLetterboxLock.lock();
+            detectLetterboxConsecutiveCounter = 0;
+            detectLetterboxDetectedMode = detectLetterboxDefaultMode;
+            detectLetterboxSwitchFrame = frameNumber;
+            detectLetterboxLock.unlock();
+        }
+        else
+        {
+            detectLetterboxConsecutiveCounter++;
+        }
+        //VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is already in widescreen (aspect: %1)").arg(video_aspect));
+        //isDetectLetterbox = false;
+        return;
+    }
+
+    // Establish the level of light in the edge
+    int averageY = 0;
+    for (int detectionLine = 0; detectionLine < NUMBER_OF_DETECTION_LINES; detectionLine++) 
+    {
+        averageY += buf[offsets[0] + 5 * pitches[0]            + xPos[detectionLine]];
+        averageY += buf[offsets[0] + (height - 6) * pitches[0] + xPos[detectionLine]];
+    }
+    averageY /= NUMBER_OF_DETECTION_LINES * 2;
+    if (averageY > 64) // To bright to be a letterbox border
+        averageY = 0;
+
+    // Scan the detection lines
+    for (int y = 5; y < height / 4; y++) // skip first pixels incase of noise in the edge
+    {
+        for (int detectionLine = 0; detectionLine < NUMBER_OF_DETECTION_LINES; detectionLine++) 
+        {
+            int Y = buf[offsets[0] +  y     * pitches[0] +  xPos[detectionLine]];
+            int U = buf[offsets[1] + (y>>1) * pitches[1] + (xPos[detectionLine]>>1)];
+            int V = buf[offsets[2] + (y>>1) * pitches[2] + (xPos[detectionLine]>>1)];
+            if ((!topHit[detectionLine]) && 
+                ( Y > averageY + THRESHOLD || Y < averageY - THRESHOLD ||
+                  U < 128 - 32 || U > 128 + 32 ||
+                  V < 128 - 32 || V > 128 + 32 ))
+            {
+                topHit[detectionLine] = y;
+                topHits++;
+                if (!minTop) 
+                    minTop = y;
+                maxTop = y;
+            }
+
+            Y = buf[offsets[0] + (height-y-1     ) * pitches[0] + xPos[detectionLine]];
+            U = buf[offsets[1] + (height-y-1 >> 1) * pitches[1] + (xPos[detectionLine]>>1)];
+            V = buf[offsets[2] + (height-y-1 >> 1) * pitches[2] + (xPos[detectionLine]>>1)];
+            if ((!bottomHit[detectionLine]) && 
+                ( Y > averageY + THRESHOLD || Y < averageY - THRESHOLD ||
+                  U < 128 - 32 || U > 128 + 32 ||
+                  V < 128 - 32 || V > 128 + 32 ))
+            {
+                bottomHit[detectionLine] = y;
+                bottomHits++;
+                if (!minBottom) 
+                    minBottom = y;
+                maxBottom = y;
+            }
+        }
+
+        if (topHits == NUMBER_OF_DETECTION_LINES && bottomHits == NUMBER_OF_DETECTION_LINES)
+        {            
+            break;
+        }
+    }
+    if (topHits != NUMBER_OF_DETECTION_LINES) maxTop = height / 4;
+    if (!minTop) minTop = height / 4;
+    if (bottomHits != NUMBER_OF_DETECTION_LINES) maxBottom = height / 4;
+    if (!minBottom) minBottom = height / 4;
+
+    bool horizontal = ((minTop && maxTop - minTop < HORIZONTAL_THRESHOLD) && 
+                       (minBottom && maxBottom - minBottom < HORIZONTAL_THRESHOLD));
+
+    if (detectLetterboxSwitchFrame > frameNumber) // user is reversing
+    {
+        detectLetterboxLock.lock();
+        detectLetterboxDetectedMode = GetAdjustFill();
+        detectLetterboxSwitchFrame = -1;
+        detectLetterboxPossibleHalfFrame = -1;
+        detectLetterboxPossibleFullFrame = -1;
+        detectLetterboxLock.unlock();
+    }
+
+    if (minTop < halfLimit || minBottom < halfLimit)
+        detectLetterboxPossibleHalfFrame = -1;
+    if (minTop < fullLimit || minBottom < fullLimit)
+        detectLetterboxPossibleFullFrame = -1;
+
+    if (detectLetterboxDetectedMode != kAdjustFill_Full) 
+    {
+        if (detectLetterboxPossibleHalfFrame == -1 && 
+            minTop > halfLimit && minBottom > halfLimit) {
+            detectLetterboxPossibleHalfFrame = frameNumber;
+        }
+    }
+    else 
+    {
+        if (detectLetterboxPossibleHalfFrame == -1 &&
+            minTop < fullLimit && minBottom < fullLimit) {
+            detectLetterboxPossibleHalfFrame = frameNumber;
+        }
+    }
+    if (detectLetterboxPossibleFullFrame == -1 && minTop > fullLimit && minBottom > fullLimit)
+        detectLetterboxPossibleFullFrame = frameNumber;
+
+    if ( maxTop < halfLimit || maxBottom < halfLimit) // Not to restrictive when switching to off
+    {
+        // No Letterbox
+        if (detectLetterboxDetectedMode != detectLetterboxDefaultMode)
+        {
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Non Letterbox detected on line: %1 (limit: %2)").arg(min(maxTop, maxBottom)).arg(halfLimit));
+            detectLetterboxLock.lock();
+            detectLetterboxConsecutiveCounter = 0;
+            detectLetterboxDetectedMode = detectLetterboxDefaultMode;
+            detectLetterboxSwitchFrame = frameNumber;
+            detectLetterboxLock.unlock();
+        }
+        else
+        {
+            detectLetterboxConsecutiveCounter++;
+        }
+    }
+    else if (horizontal && minTop > halfLimit && minBottom > halfLimit &&
+             maxTop < fullLimit && maxBottom < fullLimit)
+    {
+        // Letterbox (with narrow bars)
+        if (detectLetterboxDetectedMode != kAdjustFill_Half)
+        {
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Narrow Letterbox detected on line: %1 (limit: %2) frame: %3").arg(minTop).arg(halfLimit).arg(detectLetterboxPossibleHalfFrame));
+            detectLetterboxLock.lock();
+            detectLetterboxConsecutiveCounter = 0;
+            if (detectLetterboxDetectedMode == kAdjustFill_Full && 
+                detectLetterboxSwitchFrame != -1) {
+                // Do not change switch frame if switch to Full mode has not been executed yet
+            }
+            else
+                detectLetterboxSwitchFrame = detectLetterboxPossibleHalfFrame;
+            detectLetterboxDetectedMode = kAdjustFill_Half;
+            detectLetterboxLock.unlock();
+        }
+        else
+        {
+            detectLetterboxConsecutiveCounter++;
+        }
+    }
+    else if (horizontal && minTop > fullLimit && minBottom > fullLimit)
+    {
+        // Letterbox
+        detectLetterboxPossibleHalfFrame = -1;
+        if (detectLetterboxDetectedMode != kAdjustFill_Full)
+        {
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Detected Letterbox on line: %1 (limit: %2) frame: %2").arg(minTop).arg(fullLimit).arg(detectLetterboxPossibleFullFrame));
+            detectLetterboxLock.lock();
+            detectLetterboxConsecutiveCounter = 0;
+            detectLetterboxDetectedMode = kAdjustFill_Full;
+            detectLetterboxSwitchFrame = detectLetterboxPossibleFullFrame;
+            detectLetterboxLock.unlock();
+        }
+        else
+        {
+            detectLetterboxConsecutiveCounter++;
+        }
+    }
+    else
+    {
+        if (detectLetterboxConsecutiveCounter <= 3)
+            detectLetterboxConsecutiveCounter = 0;
+    }
+}
+
+/** \fn NuppelVideoPlayer::SwitchToDetectedLetterbox(VideoFrame*)
+ *  \brief Switch to the mode detected by DetectLetterbox
+ *
+ *  Switch fill mode if a switch was detected for this frame.
+ */
+void NuppelVideoPlayer::SwitchToDetectedLetterbox(VideoFrame *frame)
+{
+    if (detectLetterboxSwitchFrame != -1)
+    {
+        detectLetterboxLock.lock();
+        if (detectLetterboxSwitchFrame <= frame->frameNumber && 
+            detectLetterboxConsecutiveCounter > 3) 
+        {
+            if (GetAdjustFill() != detectLetterboxDetectedMode)
+            {
+                VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Switched to %1 on frame %2 (%3)").arg(detectLetterboxDetectedMode).arg(frame->frameNumber).arg(detectLetterboxSwitchFrame));
+                videoOutput->ToggleAdjustFill(detectLetterboxDetectedMode);
+                ReinitOSD();            
+            }
+            detectLetterboxSwitchFrame = -1;
+        } 
+        else if (detectLetterboxSwitchFrame <= frame->frameNumber)
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Not Switched to %1 on frame %2 (%3) Not enough consecutive detections (%4)").arg(detectLetterboxDetectedMode).arg(frame->frameNumber).arg(detectLetterboxSwitchFrame).arg(detectLetterboxConsecutiveCounter));
+
+        detectLetterboxLock.unlock();
+    }
+}
+
 void NuppelVideoPlayer::DisplayNormalFrame(void)
 {
     SetVideoActuallyPaused(false);
@@ -2848 +3114 @@
     // handle scan type changes
     AutoDeint(frame);
 
+    if (isDetectLetterbox)
+        SwitchToDetectedLetterbox(frame);
+
     videofiltersLock.lock();
     if (ringBuffer->isDVD() &&
         ringBuffer->DVD()->InStillFrame() &&
@@ -5034 +5303 @@
 {
     if (videoOutput)
     {
+        isDetectLetterbox = false;
         videoOutput->ToggleAdjustFill(adjustfillMode);
         ReinitOSD();
     }
 }
 
+void NuppelVideoPlayer::SetDetectLetterbox(bool detect)
+{
+    isDetectLetterbox = detect;
+    detectLetterboxSwitchFrame = -1;
+    detectLetterboxDetectedMode = GetAdjustFill();
+}
+
+bool NuppelVideoPlayer::GetDetectLetterbox()
+{
+    return isDetectLetterbox;
+}
+
 void NuppelVideoPlayer::Zoom(ZoomDirection direction)
 {
     if (videoOutput)

libs/libmythtv/NuppelVideoPlayer.h

@@ -179 +179 @@
     void ToggleAspectOverride(AspectOverrideMode aspectMode = kAspect_Toggle);
     void ToggleAdjustFill(AdjustFillMode adjustfillMode = kAdjustFill_Toggle);
 
+    void SetDetectLetterbox(bool detect);
+    bool GetDetectLetterbox();
+
     // Gets
     QSize   GetVideoBufferSize(void) const    { return video_dim; }
     QSize   GetVideoSize(void) const          { return video_disp_dim; }
@@ -521 +524 @@
     long long GetDVDBookmark(void) const;
     void SetDVDBookmark(long long frames);
 
+    void DetectLetterbox(VideoFrame *frame);
+    void SwitchToDetectedLetterbox(VideoFrame *frame);
   private:
     DecoderBase   *decoder;
     QMutex         decoder_change_lock;
@@ -801 +806 @@
 
     // Debugging variables
     Jitterometer *output_jmeter;
+
+    bool isDetectLetterbox;
+
+    AdjustFillMode detectLetterboxDefaultMode;
+    AdjustFillMode detectLetterboxDetectedMode; // Wich mode was last detected
+    long long  detectLetterboxSwitchFrame; // On wich frame was the mode switch detected
+    long long detectLetterboxPossibleHalfFrame;
+    long long detectLetterboxPossibleFullFrame;
+    int detectLetterboxConsecutiveCounter;
+
+    int detectLetterboxLimit;
+    QMutex detectLetterboxLock;
 };
 
 #endif

libs/libmythtv/tv_play.cpp

@@ -7397 +7397 @@
     {
         ToggleAdjustFill((AdjustFillMode) action.right(1).toInt());
     }
+    else if (action == "AUTODETECT_FILL")
+    {
+        nvp->SetDetectLetterbox(!nvp->GetDetectLetterbox());
+    }
     else if (action == "GUIDE")
         EditSchedule(kScheduleProgramGuide);
     else if (action == "FINDER")
@@ -7569 +7573 @@
 
     AdjustFillMode adjustfill = nvp->GetAdjustFill();
     OSDGenericTree *af_item = new OSDGenericTree(treeMenu, tr("Adjust Fill"));
+    OSDGenericTree *subitem = new OSDGenericTree(af_item, tr("Auto Detect"),
+                                 "AUTODETECT_FILL",
+                                 (nvp->GetDetectLetterbox()) ? 1 : 0,
+                                 NULL, "ADJUSTFILLGROUP");
+
     for (int i = kAdjustFill_Off; i < kAdjustFill_END; i++)
     {
         bool sel = (i != kAdjustFill_Off) ? (adjustfill == i) :

libs/libmythtv/videoouttypes.h

@@ -45 +45 @@
     kAdjustFill_Half,
     kAdjustFill_Full,
     kAdjustFill_Stretch,
-    kAdjustFill_END
+    kAdjustFill_END,
+    kAdjustFill_AutoDetect_DefaultOff = 16,
+    kAdjustFill_AutoDetect_DefaultHalf
 } AdjustFillMode;
 
 typedef enum LetterBoxColour
@@ -217 +219 @@
         case kAdjustFill_Toggle:
         case kAdjustFill_Off:
         case kAdjustFill_END: break;
+        case kAdjustFill_AutoDetect_DefaultOff: ret = QObject::tr("Auto Detect (Default Off)");    break;
+        case kAdjustFill_AutoDetect_DefaultHalf: ret = QObject::tr("Auto Detect (Default Half)");    break;
     }
 
     ret.detach();

libs/libmythtv/videooutbase.cpp

@@ -392 +392 @@
         db_vdisp_profile->SetInput(video_dim);
 
     aspectoverride  = db_aspectoverride;
-    adjustfill      = db_adjustfill;
+    // If autodection is enabled. Start in the defaultmode
+    adjustfill      = db_adjustfill >= kAdjustFill_AutoDetect_DefaultOff ? 
+        (AdjustFillMode) (db_adjustfill - kAdjustFill_AutoDetect_DefaultOff) : db_adjustfill;
 
     VideoAspectRatioChanged(aspect); // apply aspect ratio and letterbox mode
 

programs/mythfrontend/globalsettings.cpp

@@ -2386 +2386 @@
 {
     HostComboBox *gc = new HostComboBox("AdjustFill");
     gc->setLabel(QObject::tr("Zoom"));
+    gc->addSelection(toString(kAdjustFill_AutoDetect_DefaultOff), QString::number(kAdjustFill_AutoDetect_DefaultOff));
+    gc->addSelection(toString(kAdjustFill_AutoDetect_DefaultHalf), QString::number(kAdjustFill_AutoDetect_DefaultHalf));
     for (int m = kAdjustFill_Off; m < kAdjustFill_END; m++)
         gc->addSelection(toString((AdjustFillMode)m), QString::number(m));
     gc->setHelpText(QObject::tr(