|| || || || || || || ||

---

VideoIndexValidator.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_VideoIndexValidator_h
#define Impala_Core_VideoSet_VideoIndexValidator_h

#include "Basis/ILog.h"
#include "Basis/StringList.h"
#include "Util/Database.h"
#ifdef AVC_USED
#include "Core/Stream/RgbDataSrcLavc.h"
#include "Core/Stream/RgbDataSrcLavc_old.h"
#endif

namespace Impala 
{
namespace Core 
{
namespace VideoSet 
{

//using namespace Stream;

class VideoIndexValidator : public Listener
{

public:

    VideoIndexValidator(Reporter* reporter, CmdOptions& options)
    {
        mSrcType = options.GetString("src");
        mEnabled = false;
    };

    ~VideoIndexValidator()
    {
    }

    void
    HandleNewWalk(VideoSet* vs)
    {
        if (mSrcType != "lavcadhocidx")
        {
            ILOG_ERROR("Invalid source type: " << mSrcType);
            return;
        }
        mEnabled = true;
    }

    void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src = 0)
    {
        if (!mEnabled)
            return;

        ILOG_INFO("Starting index validation for file nr. " << fileId);

        bool usingExistingSrc = (src != 0);
        if (!usingExistingSrc)
        {
            src = vs->GetVideo(fileId);
            if (src == 0)
            {
                ILOG_ERROR("Failed to instantiate RGB new data" <<
                    " source implementation for video nr. " << fileId);
                return;
            }
        }

        const String srcName = src->GetName();

        ILOG_INFO("Video and index instantiated using " <<
            "new implementation for file nr. " << fileId);

        Stream::RgbDataSrcInfo* srcNewImpl = (Stream::RgbDataSrcInfo*) src;
        const int leadingBadFramesNew = src->LeadingBadFrames();

        // calc required hash buffer size; stay on the safe side, add 10%
        int hashBufferSize = (srcNewImpl->LastFrame() + 1) * (32 + 1) * 1.10;
        char* hashBufferNew = new char[hashBufferSize];
        const int bytesWrittenNew = 
            srcNewImpl->DumpIndexHashes(hashBufferNew, hashBufferSize);
        if (!usingExistingSrc)
            delete src;
        src = 0;

        if (bytesWrittenNew >= hashBufferSize)
        {
            ILOG_ERROR("Hash (new) buffer overflow for video nr. " << fileId);
            delete [] hashBufferNew;
            return;
        }
        hashBufferNew[bytesWrittenNew] = '\0';
        

#ifdef AVC_USED
        // retrieve frame hashes according to old indexing implementation
        Util::Database* db = vs->GetDatabase();
        Stream::RgbDataSrcInfo* srcOldImpl = 
            new Stream::RgbDataSrcLavc_old(
            Stream::RgbDataSrcFactory::SRC_LAVC_ADHOCIDX, srcName, db, ADHOCIDX);
        if (!srcOldImpl)
        {
            ILOG_ERROR("Failed to instantiate RGB old data" <<
                " source implementation for video nr. " << fileId);
            delete [] hashBufferNew;
            return;
        }

        ILOG_INFO("Video and index instantiated using " <<
            "old implementation for file nr. " << fileId);


        const int leadingBadFramesOld = srcOldImpl->LeadingBadFrames();

        hashBufferSize = (srcOldImpl->LastFrame() + 1) * (32 + 1) * 1.10;
        char* hashBufferOld = new char[hashBufferSize];
        const int bytesWrittenOld = 
            srcOldImpl->DumpIndexHashes(hashBufferOld, hashBufferSize);
        delete srcOldImpl;
        srcOldImpl = 0;

        if (bytesWrittenOld < 0)
        {
            ILOG_ERROR("Hash (old) buffer overflow for video nr. " << fileId);
            delete [] hashBufferNew;
            delete [] hashBufferOld;
            return;
        }
        hashBufferOld[bytesWrittenOld] = '\0';

        ILOG_INFO("Comparing results for old and new implementation");

        // compare buffer sizes 
        if (bytesWrittenNew != bytesWrittenOld)
        {
            ILOG_WARN("Hash buffer length mismatch for video nr. " << 
                fileId << "; existing=" << 
                bytesWrittenOld << ", new=" << 
                bytesWrittenNew);
        }


        // compare leading bad frame count
        if (leadingBadFramesOld == leadingBadFramesNew)
        {
            ILOG_INFO("Identical number of reported leading bad frames" <<
                " (\"blank frames\") : " << leadingBadFramesOld);
        }
        else
            ILOG_ERROR("Different number of reported leading bad frames" <<
                " (\"blank frames\"); old : " << leadingBadFramesOld << 
                ", new : " << leadingBadFramesNew);


        // compare hashes from the two buffers pair-wise

        StringList oldHashList(hashBufferOld, '\t', true);
        StringList newHashList(hashBufferNew, '\t', true);
        StringListI oldHashIter = oldHashList.begin();
        StringListI newHashIter = newHashList.begin();
        int oldHashCount = 0;
        int newHashCount = 0;
        static const int TEN = 10;
        int hashID = 0;
        int compared = 0;
        int nrOfMismatches = 0;
        bool triedFastForward = false;
        while (true)
        {
            if (oldHashIter != oldHashList.end())
            {
                if (newHashIter != newHashList.end())
                {
                    if (*oldHashIter == *newHashIter)
                    {
                        ILOG_DEBUG(hashID << ":  [" << *oldHashIter << 
                            "] -> [" << *newHashIter << "]");
                    }
                    else
                    {
                        ILOG_ERROR(hashID << ":  [" << *oldHashIter << 
                            "] -> [" << *newHashIter << "]  :  Hash mismatch!");
                        nrOfMismatches++;
                    }
                    if (*newHashIter != Stream::RgbDataSrcInfo::MISSING_FRAME_HASH)
                        newHashCount++;
                    newHashIter++;
                }
                else
                {
                    ILOG_ERROR(hashID << ":  [" << *oldHashIter << "] -> " << 
                        "         (no hash value)            :  Hash mismatch!");
                    nrOfMismatches++;
                }
                if (*oldHashIter != Stream::RgbDataSrcInfo::MISSING_FRAME_HASH)
                    oldHashCount++;
                oldHashIter++;
            }
            else if (newHashIter != newHashList.end())
            {
                ILOG_ERROR(hashID << ":           (no hash value)           -> [" << 
                    *newHashIter << "]   :  Hash mismatch!");
                nrOfMismatches++;
                if (*newHashIter != Stream::RgbDataSrcInfo::MISSING_FRAME_HASH)
                    newHashCount++;
                newHashIter++;
            }
            else
                break;

            compared++;
            hashID++;

            if (nrOfMismatches >= TEN && !triedFastForward)
            {
                // if possible, fast-forward to (close to) end of both lists
                const int ffCount = 
                    Min(oldHashList.size(), newHashList.size()) - compared - TEN;
                if (ffCount > 0)
                {
                    for (int i = 0; i < ffCount; i++)
                    {
                        oldHashIter++;
                        newHashIter++;
                        hashID++;
                        newHashCount++;
                        oldHashCount++;
                    }
                    ILOG_INFO("At " << TEN << " hash mismatches, skipping validation for " << ffCount << " frames");
                }
                triedFastForward = true;
            }
        }
        ILOG_INFO("Number of hash values compared: " << compared);
        if (nrOfMismatches > 0)
            ILOG_INFO("Number of mismatches: " << nrOfMismatches);

        // compare hash counts;
        if (oldHashCount > newHashCount)
        {
            ILOG_INFO("Less new hash values (" << newHashCount <<
                ") than old hash values (" << oldHashCount << ")");
        }
        else if (oldHashCount < newHashCount)
        {
            ILOG_INFO("More new hash values (" << newHashCount <<
                ") than old hash values (" << oldHashCount << ")");
        }

        delete [] hashBufferNew;
        delete [] hashBufferOld;
#else
        ILOG_ERROR("No AVC support included");
#endif
        ILOG_INFO("Index validation for file nr. " << fileId << " completed");
    }

private:

    ILOG_VAR_DECL;

    String mSrcType;
    bool mEnabled;

}; //class

ILOG_VAR_INIT(VideoIndexValidator, Impala.Core.VideoSet);

}}} //namespace Impala::Core::VideoSet

#endif

---