Ticket #4872: detectLetterboxV9.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -28 +28 @@
 #include "mythdbcon.h"
 #include "dialogbox.h"
 #include "NuppelVideoPlayer.h"
+#include "DetectLetterbox.h"
 #include "audiooutput.h"
 #include "recordingprofile.h"
 #include "osdtypes.h"
@@ -268 +269 @@
       // Debugging variables
       output_jmeter(NULL)
 {
+
+    // Playback (output) zoom control
+    detect_letter_box = new DetectLetterbox(this);
+
     vbimode = VBIMode::Parse(gContext->GetSetting("VbiFormat"));
 
     if (info)
@@ -1405 +1410 @@
     buffer->timecode = timecode;
 
     videoOutput->ReleaseFrame(buffer);
+
+    detect_letter_box->Detect(buffer);
 }
 
 /** \fn NuppelVideoPlayer::DiscardVideoFrame(VideoFrame*)
@@ -2848 +2855 @@
     // handle scan type changes
     AutoDeint(frame);
 
+    detect_letter_box->SwitchTo(frame);
+
     videofiltersLock.lock();
     if (ringBuffer->isDVD() &&
         ringBuffer->DVD()->InStillFrame() &&
@@ -5034 +5043 @@
 {
     if (videoOutput)
     {
+        detect_letter_box->SetDetectLetterbox(false);
         videoOutput->ToggleAdjustFill(adjustfillMode);
         ReinitOSD();
     }

libs/libmythtv/DetectLetterbox.cpp

@@ +1 @@
+// -*- Mode: c++ -*-
+
+// Qt headers
+#include <QApplication>
+#include <QKeyEvent>
+
+// MythTV headers
+#include "DetectLetterbox.h"
+#include "NuppelVideoPlayer.h"
+#include "videoouttypes.h"
+#include "videoout_xv.h"
+
+#ifdef USING_VDPAU
+#include "util-vdpau.h"
+#endif // USING_VDPAU
+
+DetectLetterbox::DetectLetterbox(NuppelVideoPlayer* const nvp)
+{
+    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 = nvp->GetAdjustFill();
+    detectLetterboxLimit = gContext->GetNumSetting("DetectLeterboxLimit", 75);
+    nupple_video_player = nvp;
+}
+
+DetectLetterbox::~DetectLetterbox()
+{
+}
+
+/** \fn DetectLetterbox::Detect(VideoFrame*)
+ *  \brief Detects if this frame is or is not letterboxed
+ *
+ *  If a change is detected detectLetterboxSwitchFrame and
+ *  detectLetterboxDetectedMode are set.
+ */
+void DetectLetterbox::Detect(VideoFrame *frame)
+{
+    unsigned char *buf = frame->buf;
+    int *pitches = frame->pitches;
+    int *offsets = frame->offsets;
+    const int width = frame->width;
+    const int height = frame->height;
+    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 - nupple_video_player->GetVideoAspect() * 9 / 16) / 2) * detectLetterboxLimit / 100);
+    const int halfLimit = (int) ((height * (1 - nupple_video_player->GetVideoAspect() * 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};
+
+#ifndef USING_VDPAU
+
+#endif // not USING_VDPAU
+
+#ifdef USING_VDPAU
+    VdpVideoSurface* vdpau;
+    VdpYCbCrFormat vdp_ycbcr_format;
+    vdp_ycbcr_format = VDP_YCBCR_FORMAT_YV12;
+    VdpStatus vdp_status;
+    VdpVideoSurfaceGetBitsYCbCr * vpd_video_serface_get_bits_y_cb_cd;
+    VideoOutputXv* video_output;
+#endif // USING_VDPAU
+
+    if (!GetDetectLetterbox())
+        return;
+
+    if (!nupple_video_player->getVideoOutput())
+        return;
+
+    switch (frame->codec) {
+        #ifdef USING_VDPAU
+        case FMT_VDPAU:
+            return;
+            if (frameNumber == 1)
+                VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: VDPAU frame format detected"));
+
+            memset(buf, 0, width*height*3);
+
+            pitches[0] = width;
+            pitches[1] = width >> 1;
+            pitches[2] = width >> 1 ;
+
+            offsets[0] = 0;
+            offsets[0] = width*height;
+            offsets[0] = (width*height) >> 2;
+
+            video_output = (VideoOutputXv*) nupple_video_player->getVideoOutput();
+            vdpau = video_output->getVDPAUContext()->getVdpVideoSurface();
+            vdp_status = vpd_video_serface_get_bits_y_cb_cd(*vdpau, vdp_ycbcr_format, (void* const*)buf, (const uint32_t*) pitches);
+            break;
+        #endif // USING_VDPAU
+        case FMT_YV12:
+            if (frameNumber == 1)
+                VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: YV12 frame format detected"));
+            break;
+        default:
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is not a supported frame format (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 (nupple_video_player->GetVideoAspect() > 1.5)
+    {
+        if (detectLetterboxDetectedMode != detectLetterboxDefaultMode)
+        {
+            VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: The source is already in widescreen (aspect: %1)").arg(nupple_video_player->GetVideoAspect()));
+            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 = nupple_video_player->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 DetectLetterbox::SwitchTo(VideoFrame*)
+ *  \brief Switch to the mode detected by DetectLetterbox
+ *
+ *  Switch fill mode if a switch was detected for this frame.
+ */
+void DetectLetterbox::SwitchTo(VideoFrame *frame)
+{
+    if (!GetDetectLetterbox())
+        return;
+
+    if (detectLetterboxSwitchFrame != -1)
+    {
+        detectLetterboxLock.lock();
+        if (detectLetterboxSwitchFrame <= frame->frameNumber &&
+            detectLetterboxConsecutiveCounter > 3)
+        {
+            if (nupple_video_player->GetAdjustFill() != detectLetterboxDetectedMode)
+            {
+                VERBOSE(VB_PLAYBACK, QString("Detect Letterbox: Switched to %1 on frame %2 (%3)").arg(detectLetterboxDetectedMode).arg(frame->frameNumber).arg(detectLetterboxSwitchFrame));
+                nupple_video_player->getVideoOutput()->ToggleAdjustFill(detectLetterboxDetectedMode);
+                nupple_video_player->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 DetectLetterbox::SetDetectLetterbox(bool detect)
+{
+    isDetectLetterbox = detect;
+    detectLetterboxSwitchFrame = -1;
+    detectLetterboxDetectedMode = nupple_video_player->GetAdjustFill();
+}
+
+bool DetectLetterbox::GetDetectLetterbox()
+{
+    return isDetectLetterbox;
+}
+
+/* vim: set expandtab tabstop=4 shiftwidth=4: */

libs/libmythtv/util-vdpau.h

@@ -55 +55 @@
 
     bool ShowPiP(VideoFrame * frame, QRect position);
 
+    // Allow us to grab the VDPAU Surface for things like DetectLetterbox
+    VdpVideoSurface* getVdpVideoSurface(void) const
+            { return videoSurfaces; }
+
   private:
     bool InitProcs(Display *disp, Screen *screen);
     void DeinitProcs(void);
@@ -181 +185 @@
 };
 
 #endif
-

libs/libmythtv/libmythtv.pro

@@ -347 +347 @@
     # Misc. frontend
     HEADERS += guidegrid.h              infostructs.h
     HEADERS += progfind.h               ttfont.h
+    HEADERS += DetectLetterbox.h
     SOURCES += guidegrid.cpp            infostructs.cpp
     SOURCES += progfind.cpp             ttfont.cpp
+    SOURCES += DetectLetterbox.cpp
 
     using_mheg {
         # DSMCC stuff

libs/libmythtv/tv_play.h

@@ -30 +30 @@
 class OSD;
 class RemoteEncoder;
 class NuppelVideoPlayer;
+class DetectLetterbox;
 class RingBuffer;
 class ProgramInfo;
 class MythDialog;

libs/libmythtv/DetectLetterbox.h

@@ +1 @@
+// -*- Mode: c++ -*-
+
+#include "NuppelVideoPlayer.h"
+
+using namespace std;
+
+class NuppelVideoPlayer;
+
+class MPUBLIC DetectLetterbox
+{
+public:
+    DetectLetterbox(NuppelVideoPlayer* const nvp);
+    ~DetectLetterbox();
+    void SetDetectLetterbox(bool detect);
+    bool GetDetectLetterbox();
+    void Detect(VideoFrame *frame);
+    void SwitchTo(VideoFrame *frame);
+
+private:
+    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;
+
+    NuppelVideoPlayer *nupple_video_player;
+
+    int detectLetterboxLimit;
+    QMutex detectLetterboxLock;
+};
+
+/* vim: set expandtab tabstop=4 shiftwidth=4: */

libs/libmythtv/NuppelVideoPlayer.h

@@ -47 +47 @@
 struct AVSubtitle;
 class InteractiveTV;
 class NSAutoreleasePool;
+class DetectLetterbox;
 
 struct TextContainer
 {
@@ -406 +407 @@
         hidedvdbutton = hide;
     }
 
+    // Playback (output) zoom automation
+    DetectLetterbox *detect_letter_box;
+
   protected:
     void DisplayPauseFrame(void);
     void DisplayNormalFrame(void);

libs/libmythtv/tv_play.cpp

@@ -29 +29 @@
 #include "guidegrid.h"
 #include "progfind.h"
 #include "NuppelVideoPlayer.h"
+#include "DetectLetterbox.h"
 #include "programinfo.h"
 #include "udpnotify.h"
 #include "vsync.h"
@@ -7397 +7398 @@
     {
         ToggleAdjustFill((AdjustFillMode) action.right(1).toInt());
     }
+    else if (action == "AUTODETECT_FILL")
+    {
+        nvp->detect_letter_box->SetDetectLetterbox(!nvp->detect_letter_box->GetDetectLetterbox());
+    }
     else if (action == "GUIDE")
         EditSchedule(kScheduleProgramGuide);
     else if (action == "FINDER")
@@ -7569 +7574 @@
 
     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->detect_letter_box->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
 

libs/libmythtv/videoout_xv.h

@@ -131 +131 @@
     static QStringList GetAllowedRenderers(MythCodecID myth_codec_id,
                                            const QSize &video_dim);
 
+#ifdef USING_VDPAU
+    // Allow us to grab the VDPAU context for things like DetectLetterbox
+    VDPAUContext* getVDPAUContext(void) const { return vdpau; }
+#endif
+
     VOSType VideoOutputSubType() const { return video_output_subtype; }
     void SetNextFrameDisplayTimeOffset(int delayus);
 

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(