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

---

TestVideo.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_TestVideo_h
#define Impala_Core_VideoSet_TestVideo_h

#include "Basis/ILog.h"

//#include "Core/Stream/RgbDataSrcFactory.h"
#include "Core/Stream/RgbDataSrc.h"

namespace Impala 
{
namespace Core 
{
namespace VideoSet 
{

class TestVideo:public Listener
{
    int mLevel;
    String mVideoName;
    String mSrcType;
    Stream::RgbDataSrc* mSrc;
    Reporter* mReporter;

public:

    TestVideo(Reporter* reporter, CmdOptions& options){
        mReporter = reporter;
        ILOG_INFO("Setting up frame accuracy test!");
        mLevel = options.GetInt("tlevel", -1);
        mSrcType = options.GetString("src");
        mSrc = 0;
    };

    ~TestVideo()
    {
        if (mSrc)
            delete mSrc;
    }

    void
    HandleNewWalk(VideoSet* vs)
    {
    }

    void
    HandleDoneWalk(VideoSet* vs)
    {
    }

    // Pass in either a ready to use data source, or video set + file id.
    void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src = 0)
    {
        if (src)
            mSrc = 0;
        else
        {
            src = vs->GetVideo(fileId);
            if (src == 0)
            {
                FailTest("Could not initialize video");
                return;
            }
            mSrc = src;
        }

        try
        {
            testFrameAccuracy(src);
        }
        catch (std::exception& e)
        {
            ILOG_ERROR("Test failed : " << e.what());
        }
    }

    void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src = 0)
    {
    }

    void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src = 0)
    {
        if (mSrc)
        {
            delete mSrc;
            mSrc = 0;
        }
    }

private:

    void 
    testFrameAccuracy(Stream::RgbDataSrc* src)
    {
        if (mLevel == -1)
        {
            testFrameAccuracyLevel0(src);
            testFrameAccuracyLevel1(src);
            return;
        }

        if (mLevel >= 0)
            testFrameAccuracyLevel0(src);
        if (mLevel >= 1)
            testFrameAccuracyLevel1(src);
        if (mLevel >= 2)
            testFrameAccuracyLevel2(src);
        if (mLevel >= 3)
            testFrameAccuracyLevel3(src);
        if (mLevel >= 4)
            testFrameAccuracyLevel4(src);
    }
    
    // Stepping forward through the video, 1 frame at a time (full coverage)
    bool 
    testFrameAccuracyLevel0(Stream::RgbDataSrc* src)
    {
        const int level = 0;
        ILOG_NDC_PUSH("Level-" << MakeString(level));
        ILOG_INFO("Test level " << MakeString(level) << " started");
        const int lastFrameNr = src->LastFrame();
        for (int f = 0; f <= lastFrameNr; f++)
        {
            if (f > 0)
                ILOG_DEBUG("Going 1 forward");

            if (!testFrameAccuracyBase(src, f, level))
            {
                ILOG_NDC_POP;
                return false;
            }
        }
        ILOG_NDC_POP;
        return true;
    }
    
    // Stepping backward through the video, 1 frame at a time (full coverage)
    bool 
    testFrameAccuracyLevel1(Stream::RgbDataSrc* src)
    {
        const int level = 1;
        ILOG_NDC_PUSH("Level-" << MakeString(level));
        ILOG_INFO("Test level " << MakeString(level) << " started");
        const int lastFrameNr = src->LastFrame();
        for (int f = lastFrameNr; f >= 0; f--)
        {   
            if (f < lastFrameNr)
                ILOG_DEBUG("Going 1 backward");

            if (!testFrameAccuracyBase(src, f, level))
            {
                ILOG_NDC_POP;
                return false;
            }
        }
        ILOG_NDC_POP;
        return true;
    }
    
    // Stepping forward through the video (no full coverage)
    bool 
    testFrameAccuracyLevel2(Stream::RgbDataSrc* src)
    {
        const int level = 2;
        ILOG_NDC_PUSH("Level-" << MakeString(level));
        ILOG_INFO("Test level " << MakeString(level) << " started");
        const int lastFrameNr = src->LastFrame();
        int stepSize = Max(2, Max(lastFrameNr / 100, src->GopSize()));
        for (int f = 0; f <= lastFrameNr; f += stepSize)
        {
            if (f > 0)
                ILOG_DEBUG("Going " << stepSize << " forwards");

            if (!testFrameAccuracyBase(src, f, level))
            {
                ILOG_NDC_POP;
                return false;
            }
        }
        ILOG_NDC_POP;
        return true;
    }

    // Stepping back through the video (no full coverage)
    bool 
    testFrameAccuracyLevel3(Stream::RgbDataSrc* src)
    {
        const int level = 3;
        ILOG_NDC_PUSH("Level-" << MakeString(level));
        ILOG_INFO("Test level " << MakeString(level) << " started");
        const int lastFrameNr = src->LastFrame();
        int stepSize = Max(2, Max(lastFrameNr / 100, src->GopSize()));
        for (int f = lastFrameNr; f >= 0; f -= stepSize)
        {
            if (f < lastFrameNr)
                ILOG_DEBUG("Going " << stepSize << " backwards");

            if (!testFrameAccuracyBase(src, f, level))
            {
                ILOG_NDC_POP;
                return false;
            }
        }
        ILOG_NDC_POP;
        return true;
    }

    // Jumping randomly through the video (no full coverage)
    bool 
    testFrameAccuracyLevel4(Stream::RgbDataSrc* src)
    {
        const int level = 4;
        ILOG_NDC_PUSH("Level-" << MakeString(level));
        ILOG_INFO("Test level " << MakeString(level) << " started");

        //SK: video v Jun
        testFrameAccuracyBase(src, 529, level);
        testFrameAccuracyBase(src, 530, level);
        testFrameAccuracyBase(src, 531, level);

        // SK: target selection algorithm by Taylan
        int targets[100];
        srand ( time(NULL) );
        targets[0] = 1;
        targets[1] = 11;
        targets[2] = 32;
        const int lastFrameNr = src->LastFrame();
        for (int i = 3; i < 98; i++)
        {
            targets[i] = (lastFrameNr - 5) * ( (1.0 * rand()) / RAND_MAX);
        }
        targets[98] = lastFrameNr - 5;
        targets[99] = 0;

        for (int i = 0; i < 100; i++)
        {
            ILOG_DEBUG("Going to " << targets[i]);
            if (!testFrameAccuracyBase(src, targets[i], level))
            {
                ILOG_NDC_POP;
                return false;
            }
        }
        ILOG_NDC_POP;
        return true;
    }
    
    bool 
    testFrameAccuracyBase(Stream::RgbDataSrc* src, int targetFrame, int testLevel)
    {
        src->GotoFrame(targetFrame);
            ILOG_DEBUG("Current frame is " << src->FrameNr());

        if (!src->IsFrameAccurate())
        {
            String errFrame = MakeString(src->FrameNr());
            String level = MakeString(testLevel);
            FailTest("Frame accuracy level " + level + " at frame: " + errFrame);
            return false;
        }

        return true;
    }

    void 
    FailTest(String msg)
    {
        ILOG_ERROR("Test failed: " << msg);
    }

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(TestVideo, Impala.Core.VideoSet);
// Registers the fixture into the CppUnit tests repository

}}}//namespace Impala.Core.VideoSet


#endif

---