Ticket #4872: detectLetterboxV6.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -289 +289 @@
     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;
+    isDetectLetterboxDebugging = false;
+    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)
@@ -374 +385 @@
 
 void NuppelVideoPlayer::SetWatchingRecording(bool mode)
 {
-    QMutexLocker locker(&decoder_change_lock);
+    QMutexLocker locker(&decoder_change_lock); // 
 
     watchingrecording = mode;
     if (GetDecoder())
@@ -1305 +1316 @@
     buffer->timecode = timecode;
 
     videoOutput->ReleaseFrame(buffer);
+
+    if (isDetectLetterbox)
+        DetectLetterbox(buffer, false);
 }
 
+
 /** \fn NuppelVideoPlayer::DiscardVideoFrame(VideoFrame*)
  *  \brief Places frame in the available frames queue.
  */
@@ -2607 +2622 @@
     return true;
 }
 
+// Debug method for DetectLetterbox
+// RED:    76, 109, 207
+// GREEN: 150,  91,  62
+void draw(VideoFrame *frame,int x, int y, unsigned char Y, unsigned char U, unsigned char V) {
+    unsigned char *buf = frame->buf;
+    int *pitches = frame->pitches; // Y, U, & V pitches
+    int *offsets = frame->offsets; // Y, U, & V offsets
+
+    buf[offsets[0] +  y     * pitches[0] +  x]     = Y;
+    buf[offsets[1] + (y>>1) * pitches[1] + (x>>1)] = U;
+    buf[offsets[2] + (y>>1) * pitches[2] + (x>>1)] = V;
+}
+
+void NuppelVideoPlayer::DetectLetterbox(VideoFrame *frame, bool debug)
+{
+    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"));
+        isDetectLetterbox = false;
+        return;
+    }
+
+    if (frameNumber < 0)
+    {
+        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Strange frame number %1").arg(frameNumber));
+        return;
+    }
+
+    if (video_aspect > 1.5) 
+    {
+        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;
+
+    if (!debug)
+    {
+        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;
+        }
+    } 
+    else 
+    {
+        // draw debug output
+        for (int x = 0; x < width; x++) 
+        { 
+            // detection lines
+            if (topHits == NUMBER_OF_DETECTION_LINES && maxTop - minTop <= HORIZONTAL_THRESHOLD) 
+            {
+                // horizontal line
+                draw (frame, x, halfLimit, 150, 91, 62);
+                draw (frame, x, fullLimit, 150, 91, 62);
+            }
+            else
+            {
+                draw (frame, x, halfLimit, 255, 128, 128);
+                draw (frame, x, fullLimit, 255, 128, 128);
+            }
+
+            if (bottomHits == NUMBER_OF_DETECTION_LINES && maxBottom - minBottom <= HORIZONTAL_THRESHOLD)
+            {
+                // horizontal line
+                draw (frame, x, height - 1 - halfLimit, 150, 91, 62);
+                draw (frame, x, height - 1 - fullLimit, 150, 91, 62);
+            }
+            else
+            {
+                draw (frame, x, height - 1 - halfLimit, 255, 128, 128);
+                draw (frame, x, height - 1 - fullLimit, 255, 128, 128);
+            }
+
+//             if (GetAdjustFill() == kAdjustFill_Full) {
+//                 draw (frame, x, (height - width * 9 / 16) / 2, 128, 255, 255);
+//                 draw (frame, x, height - (height - width * 9 / 16) / 2, 128, 255, 255);
+//             } else if (GetAdjustFill() == kAdjustFill_Half) {
+//                 draw (frame, x, (height - width * 9 / 14) / 2, 128, 255, 255);
+//                 draw (frame, x, height - (height - width * 9 / 14) / 2, 128, 255, 255);
+//             }
+        }
+
+        for (int y = 5; y < height / 4; y++) 
+        {
+            int line;
+            for (line = 0; line < NUMBER_OF_DETECTION_LINES; line++) 
+            {
+                if (topHit[line] > y || !topHit[line])
+                    draw (frame, xPos[line], y, 150, 91, 62); 
+                else 
+                    draw (frame, xPos[line], y, 76, 109, 207); 
+        
+                if (bottomHit[line] > y || !bottomHit[line]) 
+                    draw (frame, xPos[line], height - 1 - y, 150, 91, 62); 
+                else 
+                    draw (frame, xPos[line], height - 1 - y, 76, 109, 207); 
+            }
+
+        }
+
+        for (int x = 0; x < 32; x ++) 
+        {
+            for (int y = 0; y < 32; y++) 
+            {
+                draw (frame, x     , y, averageY, 128, 128);
+                draw (frame, x + 48, y, averageY, 128 - 32 + x*2, 128 - 32 + y*2);            
+                draw (frame, x     , y + 48, 64, 128, 128);
+                draw (frame, x + 48, y + 48, 64, 128 - 32 + x*2, 128 - 32 + y*2);            
+            }
+        }
+    }
+}
+
+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();
+    }
+
+    if (isDetectLetterboxDebugging)
+        DetectLetterbox(frame, true);
+}
+
 void NuppelVideoPlayer::DisplayNormalFrame(void)
 {
     SetVideoActuallyPaused(false);
@@ -2715 +3046 @@
     // handle scan type changes
     AutoDeint(frame);
 
+    if (isDetectLetterbox)
+        SwitchToDetectedLetterbox(frame);
+
     videofiltersLock.lock();
     if (ringBuffer->isDVD() &&
         ringBuffer->DVD()->InStillFrame() &&
@@ -4888 +5222 @@
 {
     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::SetDetectLetterboxDebugging(bool debug)
+{
+    isDetectLetterboxDebugging = debug;
+}
+
+bool NuppelVideoPlayer::GetDetectLetterboxDebugging()
+{
+    return isDetectLetterboxDebugging;
+}
+
 void NuppelVideoPlayer::Zoom(ZoomDirection direction)
 {
     if (videoOutput)

libs/libmythtv/NuppelVideoPlayer.h

@@ -176 +176 @@
     void ToggleAspectOverride(AspectOverrideMode aspectMode = kAspect_Toggle);
     void ToggleAdjustFill(AdjustFillMode adjustfillMode = kAdjustFill_Toggle);
 
+    void SetDetectLetterbox(bool detect);
+    bool GetDetectLetterbox();
+    void SetDetectLetterboxDebugging(bool detect);
+    bool GetDetectLetterboxDebugging();
+
     // Gets
     QSize   GetVideoBufferSize(void) const    { return video_dim; }
     QSize   GetVideoSize(void) const          { return video_disp_dim; }
@@ -516 +521 @@
     long long GetDVDBookmark(void) const;
     void SetDVDBookmark(long long frames);
 
+    void DetectLetterbox(VideoFrame *frame, bool debug);
+    void SwitchToDetectedLetterbox(VideoFrame *frame);
   private:
     DecoderBase   *decoder;
     QMutex         decoder_change_lock;
@@ -795 +802 @@
 
     // Debugging variables
     Jitterometer *output_jmeter;
+
+    bool isDetectLetterbox;
+    bool isDetectLetterboxDebugging;
+
+    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

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

libs/libmythtv/videoouttypes.h

@@ -46 +46 @@
     kAdjustFill_Half,
     kAdjustFill_Full,
     kAdjustFill_Stretch,
-    kAdjustFill_END
+    kAdjustFill_END,
+    kAdjustFill_AutoDetect_DefaultOff = 16,
+    kAdjustFill_AutoDetect_DefaultHalf
 } AdjustFillMode;
 
 typedef enum LetterBoxColour
@@ -208 +210 @@
         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;
     }
     return QDeepCopy<QString>(ret);
 }

libs/libmythtv/videooutbase.cpp

@@ -383 +383 @@
     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

@@ -2317 +2317 @@
 {
     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(