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

---

Walker.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_Walker_h
#define Impala_Core_VideoSet_Walker_h

#include <vector>
#include "Persistency/QuidTableRepository.h"
#include "Persistency/SegmentationRepository.h"
#include "Persistency/KeyframesRepository.h"
#include "Persistency/AnnotationTableRepository.h"
#include "Basis/ConfigBase.h"
#include "Core/Table/AnnotationTable.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/RgbDataSrcKeyframes.h"
#include "Core/VideoSet/Listener.h"
#include "Core/Geometry/DatabaseReadVxRectangle.h"
#include "Util/DatabaseReadString.h"
#include "Util/Database.h"
#include "Util/IOBuffer.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{

class WalkerConfig : public ConfigBase
{
public:
    WalkerConfig()
    {
        iFrames = false;
        keyframeSrc = false;
        partialWalk = false;
        virtualWalk = false;
        maxKeyframeMask = -1;
        numberFrames = -1;
        numberKeyframes = -1;
        numberQuids = -1;
        startKeyframe = 0;
        startQuid = 0;
        stepSize = 1;
    }

    void InitOptions(CmdOptions& co)
    {
        co.AddOption(0, "iFrames", "", "false");
        co.AddOption(0, "keyframeSrc", "", "false");
        co.AddOption(0, "virtualWalk", "", "false");
        co.AddOption(0, "partialWalk", "", "false");
        // co.AddOption(0, "maxKeyframeMask", "", "-1"); //not used in original code ?!?
        co.AddOption(0, "numberFrames", "nr",   "-1");
        co.AddOption(0, "numberKeyframes", "nr", "-1");
        co.AddOption(0, "numberQuids", "nr", "-1");
        co.AddOption(0, "startKeyframe", "idx", "0");
        co.AddOption(0, "startQuid", "idx", "0");
        co.AddOption(0, "stepSize",  "nr", "1");
    }

    void RetrieveOptions(CmdOptions& co)
    {
        iFrames          = co.GetBool("iFrames",        iFrames);
        keyframeSrc      = co.GetBool("keyframeSrc",    keyframeSrc);
        partialWalk      = co.GetBool("partialWalk",    partialWalk);
        virtualWalk      = co.GetBool("virtualWalk",    virtualWalk);
        maxKeyframeMask  = co.GetInt("maxKeyframeMask", maxKeyframeMask);
        numberFrames     = co.GetInt("numberFrames",    numberFrames);
        numberKeyframes  = co.GetInt("numberKeyframes", numberKeyframes);
        numberQuids      = co.GetInt("numberQuids",     numberQuids);
        startKeyframe    = co.GetInt("startKeyframe",   startKeyframe);
        startQuid        = co.GetInt("startQuid",       startQuid);
        stepSize         = co.GetInt("stepSize",        stepSize);
    }

private:
    bool iFrames;
    bool keyframeSrc;
    bool partialWalk;
    bool virtualWalk;
    int maxKeyframeMask;
    int numberFrames;
    int numberKeyframes;
    int numberQuids;
    int startKeyframe;
    int startQuid;
    int stepSize;

    friend class Walker;
};



class Walker
{
public:

    Walker(VideoSet* videoSet, WalkerConfig config) : mConfig(config)
    {
        mVideoSet = videoSet;
        mSegmentation = 0;
        mKeyframes = 0;
        mKeyframeMask = 0;
        mQuids = new Table::QuidTable(0);
    }
    
    virtual
    ~Walker()
    {
        for(int i = 0; i < mListeners.size(); i++)
        {
            delete mListeners[i];
        }
        mListeners.clear();
    }

    void
    AddListener(Listener* listener)
    {
        mListeners.push_back(listener);
    }

    int
    NrListeners() const
    {
        return mListeners.size();
    }

    void
    LoadSegmentation(String name)
    {
        if (mSegmentation)
            delete mSegmentation;
        Persistency::SegmentationLocator loc(mVideoSet->GetLocator(), name);
        mSegmentation = Persistency::SegmentationRepository().Get(loc,
                                                                  mVideoSet);
    }

    Segmentation*
    GetSegmentation()
    {
        return mSegmentation;
    }

    void
    LoadKeyframes(String name)
    {
        if (mKeyframes)
            delete mKeyframes;
        Persistency::KeyframesLocator loc(mVideoSet->GetLocator(), name);
        mKeyframes = Persistency::KeyframesRepository().Get(loc, mVideoSet);
    }

    Keyframes*
    GetKeyframes()
    {
        return mKeyframes;
    }

    void
    SetKeyframeMask(bool* mask)
    {
        mKeyframeMask = mask;
    }

    void
    AddRkfMask()
    {
        if (!InitKeyframeMask())
            return;
        int nrKey = mKeyframes->GetNrKeyframes();
        for (int i=0 ; i<nrKey ; i++)
            mKeyframeMask[i] &= mKeyframes->IsRKF(i);
    }

    void
    AddKeyframeMaskAnnoFile(String fileName)
    {
        if (!InitKeyframeMask())
            return;
        StringList sList(fileName, '/');
        if (sList.size() != 4)
            ILOG_ERROR("AddKeyframeMaskAnnoFile: expected 4 elements in path");
        StringListCI it = sList.begin();
        it++; // Skip Annotations
        String quidStr = *it++;
        String conceptSet = *it++;
        String keyword = FileNameBase(*it);
        Persistency::AnnotationTableLocator loc(mVideoSet->GetLocator(),
                                                StringToQuidClass(quidStr),
                                                conceptSet, keyword);
        Table::AnnotationTable* annoTable = 
            Persistency::AnnotationTableRepository().Get(loc);
        int nrKey = mKeyframes->GetNrKeyframes();
        for (int i=0 ; i<nrKey ; i++)
        {
            Quid quid = mKeyframes->GetQuidFrame(i);
            bool present = annoTable->IsPositive(quid);
            mKeyframeMask[i] &= present;
        }
        delete annoTable;
    }

    bool*
    GetKeyframeMask()
    {
        return mKeyframeMask;
    }

    void
    LoadQuids(String fileName)
    {
        Persistency::QuidTableLocator loc(mVideoSet->GetLocator(),
                                          FileNamePath(fileName),
                                          FileNameTail(fileName));
        mQuids = Persistency::QuidTableRepository().Get(loc);
        mQuidWalkName = FileNameBase(fileName);
        mQuids->UpdateGroups();
    }

    Core::Table::QuidTable*
    GetQuids()
    {
        return mQuids;
    }

    void
    LoadBookmarks(String fileName)
    {
        mVrList.clear();
        Persistency::FileLocator loc(mVideoSet->GetLocator(), fileName);
        Geometry::DatabaseReadVxRectangle(std::back_inserter(mVrList), loc);
    }

    int
    TotalNrFramesInBookmarks()
    {
        int nr = 0;
        for (size_t i=0 ; i<mVrList.size() ; i++)
        {
            Geometry::VxRectangle vr = mVrList[i];
            nr += vr.mEndFrame - vr.mStartFrame + 1;
        }
        return nr;
    }

    // Walking part

    void
    DoWalk()
    {
        DoWalk(0, mVideoSet->NrFiles(), 0);
    }

    void
    DoWalk(int startFile, int numberFiles, int startFrame)
    {
        if (startFile >= mVideoSet->NrFiles())
        {
            ILOG_ERROR("DoWalk: startFile out of range");
            return;
        }
        if (numberFiles == -1)
            numberFiles = mVideoSet->NrFiles() - startFile;
        if (startFile + numberFiles >= mVideoSet->NrFiles())
            numberFiles = mVideoSet->NrFiles() - startFile;

        for (size_t l=0 ; l<mListeners.size() ; l++)
        {
            mListeners[l]->HandleNewWalk(mVideoSet);
            mListeners[l]->HandleNewWalk(mVideoSet, "Frames");
            if (mSegmentation)
                mListeners[l]->HandleNewWalk(mVideoSet, mSegmentation);
            //if ((mConfig.numberFrames != -1) && (!mConfig.iFrames))
            if (mConfig.partialWalk)
                mListeners[l]->HandleNewWalkPartial(mVideoSet, startFrame,
                                                    mConfig.stepSize,
                                                    mConfig.numberFrames);
        }

        for (int fileId=startFile ; fileId<startFile+numberFiles ; fileId++)
        {
            if (mConfig.virtualWalk) // cannot do much, yet...
            {
                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleNewFile(mVideoSet, fileId, 0);
                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleDoneFile(mVideoSet, fileId, 0);
                continue;
            }

            Stream::RgbDataSrc* src = mVideoSet->GetVideo(fileId);
            if (src == 0)
            {
                ILOG_ERROR("DoWalk: Failed on file: " +
                           mVideoSet->GetAsPath(fileId));
                continue;
            }

            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleNewFile(mVideoSet, fileId, src);

            if (!src->GotoFrame(startFrame))
            {
                ILOG_ERROR("DoWalk: Failed on src->GotoFrame() for file: " + 
                    mVideoSet->GetAsPath(fileId));
                delete src;
                src = 0;
            }

            if (src && mConfig.iFrames)
            {
                while (!src->CurIsIFrame() && !src->TheEnd())
                {
                    if (!src->NextFrame(mConfig.stepSize))
                    {
                        ILOG_ERROR("DoWalk: Failed on src->NextFrame() for file: " + 
                            mVideoSet->GetAsPath(fileId));
                        delete src;
                        src = 0;
                        break;
                    }
                }
            }

            if (src && src->TheEnd())
                ILOG_ERROR("DoWalk: no IFrames found");

            int lastShot = -1;
            int numberFrames = mConfig.numberFrames;
            bool done = false;
            do
            {
                if (!src)
                    break;

                if (mSegmentation)
                {
                    int frame = src->FrameNr();
                    int shot = mSegmentation->GetShotId(fileId, frame);
                    if (shot != lastShot)
                    {
                        if (lastShot != -1)
                            for (size_t l=0 ; l<mListeners.size() ; l++)
                                mListeners[l]->HandleDoneShot(mVideoSet, fileId,
                                                              src, lastShot);
                        for (size_t l=0 ; l<mListeners.size() ; l++)
                            mListeners[l]->HandleNewShot(mVideoSet, fileId,
                                                         src, shot);
                        lastShot = shot;
                    }
                }

                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleNewFrame(mVideoSet, fileId, src);

                if (mConfig.stepSize == 10000000) // special case
                {
                    done = true;
                }
                else
                {
                    // using try/catch in order to continue in case of
                    // JNI memory problems, which are signaled using exceptions;
                    try
                    {
                        src->NextFrame(mConfig.stepSize);
                        if (mConfig.iFrames)
                        {
                            while (!src->CurIsIFrame() && !src->TheEnd())
                                src->NextFrame(mConfig.stepSize);
                        }
                    }
                    catch (std::exception& e)
                    {
                        String eMsg(e.what());
                        ILOG_ERROR("DoWalk: Failed on src->NextFrame() for file: "
                                   + mVideoSet->GetAsPath(fileId) + ": " + eMsg);
                        delete src;
                        src = 0;
                        break;
                    }
                }

                if (src->TheEnd())
                    done = true;

                if (numberFrames > 0) // -1 implies no limit
                {
                    numberFrames--;
                    if (numberFrames <= 0)
                        done = true;
                }
            } while (!done);

            if (mSegmentation && (lastShot != -1))
                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleDoneShot(mVideoSet, fileId, src,
                                                  lastShot);

            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleDoneFile(mVideoSet, fileId, src);

            if (src)
                delete src;
        }

        for (size_t l=0 ; l<mListeners.size() ; l++)
            mListeners[l]->HandleDoneWalk(mVideoSet);
    }

    void
    DoWalkKeyframes(int startFile, int numberFiles)
    {
        if (mKeyframes == 0)
        {
            ILOG_ERROR("DoWalkKeyframes: no keyframes loaded");
            return;
        }
        if (startFile >= mVideoSet->NrFiles())
        {
            ILOG_ERROR("DoWalkKeyframes: startFile out of range");
            return;
        }
        if (numberFiles == -1)
            numberFiles = mVideoSet->NrFiles();
        if (startFile + numberFiles >= mVideoSet->NrFiles())
            numberFiles = mVideoSet->NrFiles() - startFile;

        for (size_t l=0 ; l<mListeners.size() ; l++)
        {
            mListeners[l]->HandleNewWalk(mVideoSet);
            mListeners[l]->HandleNewWalk(mVideoSet, "Keyframes");
            mListeners[l]->HandleNewWalk(mVideoSet, mKeyframes, mKeyframeMask);
            if (mSegmentation)
                mListeners[l]->HandleNewWalk(mVideoSet, mSegmentation);
        }
        ILOG_DEBUG("fileId range = " << startFile << " - "
                   << startFile+numberFiles);
        for (int fileId=startFile ; fileId<startFile+numberFiles ; fileId++)
        {
            ILOG_DEBUG("fileId = " << fileId);
            ILOG_NDC_PUSH("video " << fileId);
            Stream::RgbDataSrc* src = 0;
            if (mConfig.keyframeSrc)
                src = new RgbDataSrcKeyframes(mVideoSet, mKeyframes, fileId);
            else if (!mConfig.virtualWalk)
                src = mVideoSet->GetVideo(fileId);
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleNewFile(mVideoSet, fileId, src);
            int numberKeyframes = mConfig.numberKeyframes;
            int startK = mKeyframes->GetFirstKeyframeVideo(fileId);
            int numberK = mKeyframes->GetNrKeyframesVideo(fileId);
            int lastK = startK + numberK;
            ILOG_INFO("keyframes are " << startK << " - " << lastK << " (nr = "
                      << numberK << ")");
            if (mConfig.startKeyframe < numberK)
                startK += mConfig.startKeyframe;
            if (numberKeyframes == -1)
                numberKeyframes = numberK;
            //if (mConfig.startKeyframe + numberKeyframes <= numberK)
            //    numberK = numberKeyframes;
            //for (int k=startK ; k<startK+numberK ; k++)
            bool done = false;
            int k = startK;
            ILOG_DEBUG("processing " << startK << " - " << lastK << " (max "
                      << numberKeyframes << ")");
            while (!done)
            {
                if ((!mKeyframeMask) || mKeyframeMask[k])
                {
                    ILOG_DEBUG("keyframe " << k);
                    if (src)
                    {
                        ILOG_DEBUG("GotoFrame " << mKeyframes->GetFrameNr(k));
                        src->GotoFrame(mKeyframes->GetFrameNr(k));
                        ILOG_DEBUG("src at " << src->FrameNr());
                    }
                    for (size_t l=0 ; l<mListeners.size() ; l++)
                        mListeners[l]->HandleNewFrame(mVideoSet, fileId, src);
                    if (--numberKeyframes <= 0)
                        done = true;
                }
                if (++k >= lastK)
                    done = true;
            }
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleDoneFile(mVideoSet, fileId, src);
            if (src)
                delete src;
            ILOG_NDC_POP;
        }

        for (size_t l=0 ; l<mListeners.size() ; l++)
            mListeners[l]->HandleDoneWalk(mVideoSet);
    }

    void
    DoWalkQuids(int startFile, int numberFiles)
    {
        if ((mQuids == 0) || (mQuids->Size() == 0))
        {
            ILOG_ERROR("DoWalkQuids: no quids loaded");
            return;
        }
        if (startFile >= mVideoSet->NrFiles())
        {
            ILOG_ERROR("DoWalkQuids: startFile out of range");
            return;
        }
        if (numberFiles == -1)
            numberFiles = mVideoSet->NrFiles();
        if (startFile + numberFiles >= mVideoSet->NrFiles())
            numberFiles = mVideoSet->NrFiles() - startFile;

        for (size_t l=0 ; l<mListeners.size() ; l++)
        {
            mListeners[l]->HandleNewWalk(mVideoSet);
            mListeners[l]->HandleNewWalk(mVideoSet, mQuidWalkName);
            if (mSegmentation)
                mListeners[l]->HandleNewWalk(mVideoSet, mSegmentation);
        }
        ILOG_DEBUG("fileId range = " << startFile << " - "
                   << startFile+numberFiles);
        for (int fileId=startFile ; fileId<startFile+numberFiles ; fileId++)
        {
            ILOG_DEBUG("fileId = " << fileId);
            ILOG_NDC_PUSH("video " << fileId);
            int numberQuids = mConfig.numberQuids;
            int startQ = mQuids->GetFirstQuidObject(fileId);
            int numberQ = mQuids->GetNrQuidsObject(fileId);
            if (numberQ == 0)
                continue;

            int lastQ = startQ + numberQ;
            ILOG_INFO("quids are " << startQ << " - " << lastQ << " (nr = "
                      << numberQ << ")");
            if (mConfig.startQuid < numberQ)
                startQ += mConfig.startQuid;
            if (numberQuids == -1)
                numberQuids = numberQ;
            bool done = false;
            int qIdx = startQ;
            ILOG_DEBUG("processing " << startQ << " - " << lastQ << " (max "
                      << numberQuids << ")");
            Stream::RgbDataSrc* src = 0;
            if (!mConfig.virtualWalk)
                src = mVideoSet->GetVideo(fileId);
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleNewFile(mVideoSet, fileId, src);
            while (!done)
            {
                ILOG_DEBUG("quidIdx " << qIdx);
                Quid quid = mQuids->Get1(qIdx);
                if (src)
                {
                    int frameNr = QuidId(quid);
                    ILOG_DEBUG("GotoFrame " << frameNr);
                    src->GotoFrame(frameNr);
                    ILOG_DEBUG("src at " << src->FrameNr());
                }
                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleNewFrame(mVideoSet, fileId, src);
                if (--numberQuids <= 0)
                    done = true;
                if (++qIdx >= lastQ)
                    done = true;
            }
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleDoneFile(mVideoSet, fileId, src);
            if (src)
                delete src;
            ILOG_NDC_POP;
        }

        for (size_t l=0 ; l<mListeners.size() ; l++)
            mListeners[l]->HandleDoneWalk(mVideoSet);
    }

    void
    DoWalkBookmarks()
    {
        for (size_t l=0 ; l<mListeners.size() ; l++)
        {
            mListeners[l]->HandleNewWalk(mVideoSet, mVrList.size());
            mListeners[l]->HandleNewWalk(mVideoSet, "Bookmarks");
        }
        for (size_t v=0 ; v<mVrList.size() ; v++)
        {
            ILOG_INFO("Bookmark " << v << " of " << mVrList.size());
            Geometry::VxRectangle vr = mVrList[v];
            int fileId = mVideoSet->GetFileId(vr.mVideoName);
            // todo : now, video names are assumed unique. Should switch
            // to statement below, but not all .vxs files are in this format
            //int fileId = mVideoSet->GetFileId(vr.mSection, vr.mDir,
            //                                  vr.mVideoName);
            Stream::RgbDataSrc* src = mVideoSet->GetVideo(fileId);
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleNewFile(mVideoSet, fileId, src, v, vr);

            Geometry::Rectangle r = vr.mRect;
            String s = vr.mAnno;
            src->GotoFrame(vr.mStartFrame);
            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleNewFrame(mVideoSet, fileId, src, r, s);
            while (src->FrameNr() < vr.mEndFrame)
            {
                src->NextFrame();
                for (size_t l=0 ; l<mListeners.size() ; l++)
                    mListeners[l]->HandleNewFrame(mVideoSet, fileId, src, r, s);
            }

            for (size_t l=0 ; l<mListeners.size() ; l++)
                mListeners[l]->HandleDoneFile(mVideoSet, fileId, src, v, vr);
            delete src;
        }
        for (size_t l=0 ; l<mListeners.size() ; l++)
            mListeners[l]->HandleDoneWalk(mVideoSet, mVrList.size());
    }

protected:

    bool
    InitKeyframeMask()
    {
        if (mKeyframes == 0)
        {
            ILOG_ERROR("InitKeyframeMask: no keyframes loaded");
            return false;
        }
        if (mKeyframeMask)
            return true;
        int nrKey = mKeyframes->GetNrKeyframes();
        mKeyframeMask = new bool[nrKey];
        for (int i=0 ; i<nrKey ; i++)
            mKeyframeMask[i] = true;
        return true;
    }

    VideoSet*                          mVideoSet;
    Segmentation*                      mSegmentation;
    Keyframes*                         mKeyframes;
    Core::Table::QuidTable*            mQuids;
    String                             mQuidWalkName;
    std::vector<Geometry::VxRectangle> mVrList;
    std::vector<Listener*>             mListeners;
    bool*                              mKeyframeMask;
    WalkerConfig                       mConfig;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(Walker, Impala.Core.VideoSet);

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

#endif

---