Ticket #8522: commflag_split_blanks_v3.patch

File commflag_split_blanks_v3.patch, 11.4 KB (added by Jim Stichnoth <stichnot@…>, 11 years ago)
  • programs/mythfrontend/globalsettings.cpp

     
    832832    return bc;
    833833}
    834834
    835 static GlobalCheckBox *CommSkipAllBlanks()
    836 {
    837     GlobalCheckBox *bc = new GlobalCheckBox("CommSkipAllBlanks");
    838     bc->setLabel(QObject::tr("Skip blank frames after commercials"));
    839     bc->setValue(true);
    840     bc->setHelpText(QObject::tr("When using blank frame detection and "
    841                     "automatic flagging, enable this option to include blank "
    842                     "frames following commercial breaks as part of the "
    843                     "commercial break."));
    844     return bc;
    845 }
    846 
    847835static HostSpinBox *CommRewindAmount()
    848836{
    849837    HostSpinBox *gs = new HostSpinBox("CommRewindAmount", 0, 10, 1);
     
    41434131    comms->addChild(CommNotifyAmount());
    41444132    comms->addChild(MaximumCommercialSkip());
    41454133    comms->addChild(MergeShortCommBreaks());
    4146     comms->addChild(CommSkipAllBlanks());
    41474134    addChild(comms);
    41484135
    41494136#if CONFIG_DARWIN
  • programs/mythcommflag/BlankFrameDetector.h

     
    3131        { return (index) ? blankMap : breakMap; }
    3232
    3333    /* BlankFrameDetector interface. */
    34     bool getSkipCommBlanks(void) const { return skipcommblanks; }
    3534    const FrameAnalyzer::FrameMap *getBlanks(void) const { return &blankMap; }
    3635    int computeForLogoSurplus(const TemplateMatcher *tm);
    3736    int computeForLogoDeficit(const TemplateMatcher *tm);
     
    4039private:
    4140    HistogramAnalyzer       *histogramAnalyzer;
    4241    float                   fps;
    43     bool                    skipcommblanks;         /* skip commercial blanks */
    4442
    4543    FrameAnalyzer::FrameMap blankMap;
    4644    FrameAnalyzer::FrameMap breakMap;
  • programs/mythcommflag/BlankFrameDetector.cpp

     
    204204
    205205void
    206206computeBreakMap(FrameAnalyzer::FrameMap *breakMap,
    207         const FrameAnalyzer::FrameMap *blankMap, float fps, bool skipcommblanks,
     207        const FrameAnalyzer::FrameMap *blankMap, float fps,
    208208        int debugLevel)
    209209{
    210210    /*
     
    339339            break;
    340340    }
    341341
    342     /* Adjust for skipcommblanks configuration. */
     342    /* Adjust for blank intervals. */
    343343    FrameAnalyzer::FrameMap::iterator iibreak = breakMap->begin();
    344344    while (iibreak != breakMap->end())
    345345    {
    346346        long long iib = iibreak.key();
    347347        long long iie = iib + *iibreak;
     348        FrameAnalyzer::FrameMap::iterator jjbreak = iibreak;
     349        ++jjbreak;
     350        breakMap->erase(iibreak);
    348351
    349         if (!skipcommblanks)
    350         {
    351             /* Trim leading blanks from commercial break. */
    352             FrameAnalyzer::FrameMap::const_iterator iiblank =
    353                 blankMap->find(iib);
    354             FrameAnalyzer::FrameMap::iterator jjbreak = iibreak;
    355             ++jjbreak;
    356             iib += *iiblank;
    357             breakMap->erase(iibreak);
    358             breakMap->insert(iib, iie - iib);
    359             iibreak = jjbreak;
    360         }
    361         else
    362         {
    363             /* Add trailing blanks to commercial break. */
    364             ++iibreak;
    365             FrameAnalyzer::FrameMap::const_iterator jjblank =
    366                 blankMap->find(iie);
    367             iie += *jjblank;
    368             breakMap->remove(iib);
    369             breakMap->insert(iib, iie - iib);
    370         }
     352        /* Trim leading blanks from commercial break. */
     353        long long addb = *blankMap->find(iib);
     354        addb = addb / 2;
     355        if (addb > MAX_BLANK_FRAMES)
     356            addb = MAX_BLANK_FRAMES;
     357        iib += addb;
     358        /* Add trailing blanks to commercial break. */
     359        long long adde = *blankMap->find(iie);
     360        iie += adde;
     361        long long sube = adde / 2;
     362        if (sube > MAX_BLANK_FRAMES)
     363            sube = MAX_BLANK_FRAMES;
     364        iie -= sube;
     365        breakMap->insert(iib, iie - iib);
     366        iibreak = jjbreak;
    371367    }
    372368}
    373369
     
    379375    , fps(0.0f)
    380376    , debugLevel(0)
    381377{
    382     skipcommblanks = gCoreContext->GetNumSetting("CommSkipAllBlanks", 1) != 0;
    383 
    384     VERBOSE(VB_COMMFLAG, QString("BlankFrameDetector: skipcommblanks=%1")
    385             .arg(skipcommblanks ? "true" : "false"));
    386 
    387378    /*
    388379     * debugLevel:
    389380     *      0: no debugging
     
    573564    /*
    574565     * Compute breaks (breakMap).
    575566     */
    576     computeBreakMap(&breakMap, &blankMap, fps, skipcommblanks, debugLevel);
     567    computeBreakMap(&breakMap, &blankMap, fps, debugLevel);
    577568
    578569    /*
    579570     * Expand blank-frame breaks to fully include overlapping logo breaks.
     
    650641    if (breakMap.empty())
    651642    {
    652643        /* Compute breaks (breakMap). */
    653         computeBreakMap(&breakMap, &blankMap, fps, skipcommblanks, debugLevel);
     644        computeBreakMap(&breakMap, &blankMap, fps, debugLevel);
    654645        frameAnalyzerReportMap(&breakMap, fps, "BF Break");
    655646    }
    656647
  • programs/mythcommflag/ClassicCommDetector.h

     
    153153        bool logoInfoAvailable;
    154154        LogoDetectorBase* logoDetector;
    155155
    156         bool skipAllBlanks;
    157 
    158156        unsigned char *framePtr;
    159157
    160158        frm_dir_map_t blankFrameMap;
  • programs/mythcommflag/TemplateMatcher.cpp

     
    673673TemplateMatcher::adjustForBlanks(const BlankFrameDetector *blankFrameDetector,
    674674    long long nframes)
    675675{
    676     const bool skipCommBlanks = blankFrameDetector->getSkipCommBlanks();
    677676    const FrameAnalyzer::FrameMap *blankMap = blankFrameDetector->getBlanks();
    678677
    679678    /*
     
    778777        if (jj != blankMap->constEnd())
    779778        {
    780779            newbrkb = jj.key();
    781             if (!skipCommBlanks)
    782                 newbrkb += *jj;
     780            long long adj = *jj / 2;
     781            if (adj > MAX_BLANK_FRAMES)
     782                adj = MAX_BLANK_FRAMES;
     783            newbrkb += adj;
    783784        }
    784785
    785786        /*
     
    796797        if (kk != blankMap->constEnd())
    797798        {
    798799            newbrke = kk.key();
    799             if (skipCommBlanks)
    800                 newbrke += *kk;
     800            long long adj = *kk;
     801            newbrke += adj;
     802            adj /= 2;
     803            if (adj > MAX_BLANK_FRAMES)
     804                adj = MAX_BLANK_FRAMES;
     805            newbrke -= adj;
    801806        }
    802807
    803808        /*
  • programs/mythcommflag/CommDetectorBase.h

     
    99
    1010#include "programtypes.h"
    1111
     12#define MAX_BLANK_FRAMES 60
     13
    1214typedef enum commMapValues {
    1315    MARK_START   = 0,
    1416    MARK_END     = 1,
  • programs/mythcommflag/ClassicCommDetector.cpp

     
    170170    commDetectMaxCommLength =
    171171        gCoreContext->GetNumSetting("CommDetectMaxCommLength", 125);
    172172
    173     skipAllBlanks = !!gCoreContext->GetNumSetting("CommSkipAllBlanks", 1);
    174173    commDetectBlankCanHaveLogo =
    175174        !!gCoreContext->GetNumSetting("CommDetectBlankCanHaveLogo", 1);
    176175}
     
    17861785    {
    17871786        if (*it == MARK_COMM_START)
    17881787        {
    1789             lastStart = it.key();
    1790             if (skipAllBlanks)
    1791             {
    1792                 while ((lastStart > 0) &&
    1793                         (frameInfo[lastStart - 1].flagMask & COMM_FRAME_BLANK))
    1794                     lastStart--;
    1795             }
    1796             else
    1797             {
    1798                 while ((lastStart < (framesProcessed - (2 * fps))) &&
    1799                         (frameInfo[lastStart + 1].flagMask & COMM_FRAME_BLANK))
    1800                     lastStart++;
    1801             }
     1788            uint64_t lastStartLower = it.key();
     1789            uint64_t lastStartUpper = it.key();
     1790            while ((lastStartLower > 0) &&
     1791                   (frameInfo[lastStartLower - 1].flagMask & COMM_FRAME_BLANK))
     1792                lastStartLower--;
     1793            while ((lastStartUpper < (framesProcessed - (2 * fps))) &&
     1794                   (frameInfo[lastStartUpper + 1].flagMask & COMM_FRAME_BLANK))
     1795                lastStartUpper++;
     1796            uint64_t adj = (lastStartUpper - lastStartLower) / 2;
     1797            if (adj > MAX_BLANK_FRAMES)
     1798                adj = MAX_BLANK_FRAMES;
     1799            lastStart = lastStartLower + adj;
    18021800
    18031801            if (verboseDebugging)
    18041802                VERBOSE(VB_COMMFLAG, QString("Start Mark: %1 -> %2")
     
    18091807        }
    18101808        else
    18111809        {
    1812             lastEnd = it.key();
    1813             if (skipAllBlanks)
    1814             {
    1815                 while ((lastEnd < (framesProcessed - (2 * fps))) &&
    1816                         (frameInfo[lastEnd + 1].flagMask & COMM_FRAME_BLANK))
    1817                     lastEnd++;
    1818             }
    1819             else
    1820             {
    1821                 while ((lastEnd > 0) &&
    1822                         (frameInfo[lastEnd - 1].flagMask & COMM_FRAME_BLANK))
    1823                     lastEnd--;
    1824             }
     1810            uint64_t lastEndLower = it.key();
     1811            uint64_t lastEndUpper = it.key();
     1812            while ((lastEndUpper < (framesProcessed - (2 * fps))) &&
     1813                   (frameInfo[lastEndUpper + 1].flagMask & COMM_FRAME_BLANK))
     1814                lastEndUpper++;
     1815            while ((lastEndLower > 0) &&
     1816                   (frameInfo[lastEndLower - 1].flagMask & COMM_FRAME_BLANK))
     1817                lastEndLower--;
     1818            uint64_t adj = (lastEndUpper - lastEndLower) / 2;
     1819            if (adj > MAX_BLANK_FRAMES)
     1820                adj = MAX_BLANK_FRAMES;
     1821            lastEnd = lastEndUpper - adj;
    18251822
    18261823            if (verboseDebugging)
    18271824                VERBOSE(VB_COMMFLAG, QString("End Mark  : %1 -> %2")
     
    19341931    for(; i < (commercials-1); i++)
    19351932    {
    19361933        long long r = c_start[i];
     1934        long long adjustment = 0;
    19371935
    19381936        if ((r < (30 * fps)) &&
    19391937            (first_comm))
     
    19551953                x++;
    19561954            }
    19571955
    1958             if (skipAllBlanks)
    1959                 while((blankFrameMap.contains(r+1)) &&
    1960                         (c_start[i+1] != (r+1)))
     1956            while((blankFrameMap.contains(r+1)) &&
     1957                  (c_start[i+1] != (r+1)))
     1958                {
    19611959                    r++;
     1960                    adjustment++;
     1961                }
    19621962        }
    19631963        else
    19641964        {
    1965             if (skipAllBlanks)
    1966                 while(blankFrameMap.contains(r+1))
    1967                     r++;
     1965            while(blankFrameMap.contains(r+1))
     1966            {
     1967                r++;
     1968                adjustment++;
     1969            }
    19681970        }
    19691971
     1972        adjustment /= 2;
     1973        if (adjustment > MAX_BLANK_FRAMES)
     1974            adjustment = MAX_BLANK_FRAMES;
     1975        r -= adjustment;
    19701976        blankCommMap[r] = MARK_COMM_END;
    19711977        first_comm = false;
    19721978    }