Ticket #4872: detectLetterboxV5.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);
+    detectLetterboxCounterOff = 0;
+    detectLetterboxCounterHalf = 0;
+    detectLetterboxCounterFull = 0;
+    detectLetterboxLimit = gContext->GetNumSetting("DetectLeterboxLimit", 60);
 }
 
 NuppelVideoPlayer::~NuppelVideoPlayer(void)
@@ -2605 +2615 @@
     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)    
+{
+
+    unsigned char *buf = frame->buf; 
+    int width = frame->width;
+    int height = frame->height;
+    int pitch = frame->pitches[0];
+    int offset = frame->offsets[0];
+
+    
+    const int THRESHOLD = 5; // Y component has to not vary more than this in the bars
+    const int SWITCH_DELAY = 3; // How many frames of posetive detection to wait before switching
+    const int HORIZONTAL_THRESHOLD = 4; // How tolerant are we that the image has horizontal edges
+    const int NUMBER_OF_DETECTION_LINES = 3; // How many lines are we looking at
+
+    // 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);
+
+    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};
+
+    int x,y;
+    int sourceAspect = width * 10 / height;
+
+
+
+    if (!isDetectLetterbox)
+        return;    
+    if (!videoOutput)
+        return;
+
+    
+    if (frame->codec != FMT_YV12)
+    {
+        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is not in YV12"));
+        return;
+    }
+
+    if (sourceAspect > 15) 
+    {
+        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is already in widescreen"));
+        return;
+    }
+
+    // Establish the level of light in the edge
+    long averageY = 0;
+    for (int detectionLine = 0; detectionLine < NUMBER_OF_DETECTION_LINES; detectionLine++) 
+    {
+        averageY += buf[offset + 5 * pitch            + xPos[detectionLine]];
+        averageY += buf[offset + (height - 6) * pitch + xPos[detectionLine]];
+    }
+    averageY /= NUMBER_OF_DETECTION_LINES * 2;
+    if (averageY > 64)
+        averageY = 0; // To bright setting to zero
+
+    // Scan the detection lines
+    for (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[offset + y * pitch + xPos[detectionLine]];
+            if ((!topHit[detectionLine]) && ( Y > averageY + THRESHOLD || Y < averageY - THRESHOLD))
+            {
+                topHit[detectionLine] = y;
+                topHits++;
+                if (!minTop) 
+                    minTop = y;
+                maxTop = y;
+            }
+
+            Y = buf[offset + (height - y -1) * pitch + xPos[detectionLine]];
+            if ((!bottomHit[detectionLine]) && ( Y > averageY + THRESHOLD || Y < averageY - THRESHOLD))
+            {
+                bottomHit[detectionLine] = y;
+                bottomHits++;
+                if (!minBottom) 
+                    minBottom = y;
+                maxBottom = y;
+            }
+        }
+
+        if ((minTop && maxTop - minTop > HORIZONTAL_THRESHOLD) || 
+            (minBottom && maxBottom - minBottom > HORIZONTAL_THRESHOLD))
+        {
+            // No horizontal lines
+            break;
+        }
+
+        if (topHits == NUMBER_OF_DETECTION_LINES && bottomHits == NUMBER_OF_DETECTION_LINES)
+        {            
+            // Found the a image on all lines
+            if ( maxTop < halfLimit && maxBottom < halfLimit)
+            {
+                // No Letterbox
+                detectLetterboxCounterOff++;
+                detectLetterboxCounterHalf = 0;
+                detectLetterboxCounterFull = 0;
+                if (GetAdjustFill() != detectLetterboxDefaultMode)
+                {
+                  VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Non Letterbox detected on line: %1 (limit: %2 counter: %3)").arg(y).arg(halfLimit).arg(detectLetterboxCounterOff));
+                    if (detectLetterboxCounterOff >= SWITCH_DELAY) 
+                    {
+                        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Switched to Fill Off"));
+                        videoOutput->ToggleAdjustFill(detectLetterboxDefaultMode);
+                        ReinitOSD();
+                    }
+                }
+            }
+            else if (minTop > halfLimit && minBottom > halfLimit &&
+                     maxTop < fullLimit && maxBottom < fullLimit)
+            {
+                // Letterbox (with narrow bars)
+                detectLetterboxCounterOff = 0;
+                detectLetterboxCounterHalf++;
+                detectLetterboxCounterFull = 0;
+                if (GetAdjustFill() != kAdjustFill_Half)
+                {
+                  VERBOSE(VB_PLAYBACK, QString("Detect Narrow Letterbox: Letterbox detected on line: %1 (limit: %2 counter: %3)").arg(y).arg(halfLimit).arg(detectLetterboxCounterHalf));
+                    if (detectLetterboxCounterHalf >= SWITCH_DELAY) 
+                    {
+                        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Switched to Fill Half"));
+                        videoOutput->ToggleAdjustFill(kAdjustFill_Half);
+                        ReinitOSD();
+                    }
+                }
+            }
+            else if ( minTop > fullLimit && minBottom > fullLimit)
+            {
+                // Letterbox
+                detectLetterboxCounterOff = 0;
+                detectLetterboxCounterHalf = 0;
+                detectLetterboxCounterFull++;
+                if (GetAdjustFill() != kAdjustFill_Full)
+                {
+                  VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Detected Letterbox on line: %1 (limit: %2 counter: %3)\n").arg(y).arg(fullLimit).arg(detectLetterboxCounterFull));
+                    if (detectLetterboxCounterFull >= SWITCH_DELAY) 
+                    { 
+                        VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Switched to Fill Full"));
+                        videoOutput->ToggleAdjustFill(kAdjustFill_Full);
+                        ReinitOSD();
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    if (!isDetectLetterboxDebugging)
+        return;
+
+    // draw debug output
+    for (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);
+        }
+    }
+
+    for (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 (x = 0; x < 25; x ++) 
+    {
+        for (y = 0; y < 25; y++) 
+        {
+            draw (frame, x + 30, y, averageY, x*10, y*10);            
+            draw (frame, x, y, averageY, 128, 128);
+        }
+    }
+}
+
 void NuppelVideoPlayer::DisplayNormalFrame(void)
 {
     SetVideoActuallyPaused(false);
@@ -2713 +2953 @@
     // handle scan type changes
     AutoDeint(frame);
 
+    DetectLetterbox(frame);
+
     videofiltersLock.lock();
     if (ringBuffer->isDVD() &&
         ringBuffer->DVD()->InStillFrame() &&
@@ -4890 +5132 @@
 {
     if (videoOutput)
     {
+        isDetectLetterbox = false;
         videoOutput->ToggleAdjustFill(adjustfillMode);
         ReinitOSD();
     }
 }
 
+void NuppelVideoPlayer::SetDetectLetterbox(bool detect)
+{
+    isDetectLetterbox = detect;
+}
+
+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
     int     GetVideoWidth(void) const         { return video_width; }
     int     GetVideoHeight(void) const        { return video_height; }
@@ -516 +521 @@
     long long GetDVDBookmark(void) const;
     void SetDVDBookmark(long long frames);
 
+    void DetectLetterbox(VideoFrame *frame);
   private:
     DecoderBase   *decoder;
     QMutex         decoder_change_lock;
@@ -796 +802 @@
 
     // Debugging variables
     Jitterometer *output_jmeter;
+
+    bool isDetectLetterbox;
+    bool isDetectLetterboxDebugging;
+    AdjustFillMode detectLetterboxDefaultMode;
+    int detectLetterboxCounterOff;
+    int detectLetterboxCounterHalf;
+    int detectLetterboxCounterFull;
+    int detectLetterboxLimit;
 };
 
 #endif

libs/libmythtv/tv_play.cpp

@@ -7317 +7317 @@
     {
         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")
@@ -7483 +7491 @@
 
     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

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

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