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

---

mainVideo.cpp

Go to the documentation of this file.

#include "Visualization/Window.h"
#include "Basis/Timer.h"
#include "Core/Stream/RgbDataSrcFactory.h"
#include "Core/Stream/RgbDataDstFactory.h"
#include "Core/Array/Rotate.h"
#include "Core/Array/WriteRaw.h"

// since we are not using libraries:
#include "OglGui/OglLib.cpp"
#include "Link/ImpalaLib.cpp"

namespace Impala
{
namespace Application
{
namespace Video
{


using namespace Impala::Util;
using namespace Impala::Core::Array;
using namespace Impala::Core::Stream;

// command line parameters
int  gVerbose;
int  gStepSize;
bool gRotateLeft;
bool gRotateRight;
int  gGopSize;
bool gDoRandom;
bool gDoLoop;
int  gNrFrames;

char gStatusBuf[256];
int  gFramesDone = 0;

RgbDataSrc* gSrc = 0;
RgbDataDst* gDst = 0;
int         gDstWidth;
int         gDstHeight;
Timer       gTimer(1);


void
FpsReset()
{
    gTimer.Start();
    gFramesDone = 0;
}

void
UpdateStatusBuf()
{
    double timeVal = gTimer.SplitTime();
    double fps = (double) gFramesDone / timeVal;
    std::ostrstream statusStream;
    statusStream << "FrameNr = " << gSrc->FrameNr() << ", did "
                 << gFramesDone << " frames in " << timeVal << " sec = "
                 << fps << " fps" << std::ends;
    strcpy(gStatusBuf, statusStream.str());
    statusStream.freeze(false);
}

int
DemoVideo()
{
    int done = 0;
    Array2dVec3UInt8* rotIm = 0;
    gTimer.Start();
    while (!done)
    {
        if (gDoRandom)
        {
            int maxFrame = (gSrc->LastFrame()/gGopSize)*gGopSize;
            int rFrame = rand()*maxFrame/RAND_MAX;
            gSrc->GotoFrame(rFrame);
        }
        else
        {
            gSrc->NextFrame(gStepSize);
        }

        if (! gSrc->DataPtr())
        {
            std::cout << "skipping empty frame" << std::endl;
            continue;
        }
        if (gRotateLeft || gRotateRight)
        {
            int degrees = (gRotateLeft) ? 90 : -90;
            Array2dVec3UInt8* wrap = new Array2dVec3UInt8(gSrc->FrameWidth(),
                                                          gSrc->FrameHeight(),
                                                          0, 0, gSrc->DataPtr(),
                                                          true);
            Rotate(rotIm, wrap, degrees, Core::Geometry::NEAREST, true, 0);
            gDst->NextFrame(rotIm->CPB());
            delete wrap;
        }
        else
        {
            gDst->NextFrame(gSrc->DataPtr());
        }
        gFramesDone++;
        if ((gVerbose > 0) && (gFramesDone % gVerbose == 0))
        {
            UpdateStatusBuf();
            std::cout << gStatusBuf << std::endl;
        }

        UpdateStatusBuf();
        done = gDst->WindowManage(done, gStatusBuf);
        if (gSrc->TheEnd())
        {
            if (gDoLoop)
            {
                gSrc->Reset();
                FpsReset();
            }
            else
            {
                done = 1;
                gDst->Close();
            }
        }
        if ((gNrFrames != -1) && (gFramesDone > gNrFrames))
        {
            done = 1;
            gDst->Close();
        }
    }
    if (rotIm)
        delete rotIm;
    return 0;
}

int
mainVideo(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true);
    options.AddOption(0, "rotateLeft", "", "0");
    options.AddOption(0, "rotateRight", "", "0");
    options.AddOption(0, "gop", "nr", "15");
    options.AddOption(0, "random", "", "0");
    options.AddOption(0, "dstDX", "", "0");
    if (! options.ParseArgs(argc, argv, "camera|filename ogl|win|filename", 2))
        return 1;

    gVerbose = options.GetInt("verb");
    gStepSize = options.GetInt("stepSize");
    gRotateLeft = options.GetBool("rotateLeft");
    gRotateRight = options.GetBool("rotateRight");
    gGopSize = options.GetInt("gop");
    gDoRandom = options.GetBool("random");
    gDoLoop = options.GetBool("loop");
    gNrFrames = options.GetInt("numberFrames");

    std::string srcName = options.GetArg(0);
    RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();
    gSrc = factory.Construct(srcName, options.GetString("src"));
    if (! gSrc->Valid())
    {
        std::cout << "RgbDataSrc failed" << std::endl;
        return 0;
    }
    if (gVerbose)
        std::cout << gSrc->LastFrame()+1 << " frames of " << gSrc->FrameWidth() 
                  << " x " << gSrc->FrameHeight() << std::endl;

    std::string dstName = options.GetArg(1);
    int theDataDst = RgbDataDstFactory::DST_OGL;
    if (dstName == "ogl")
        theDataDst = RgbDataDstFactory::DST_OGL;
    else if (dstName == "win")
        theDataDst = RgbDataDstFactory::DST_WIN;
    else theDataDst = RgbDataDstFactory::DST_AVI;
    if (options.GetBool("dstDX"))
        theDataDst = RgbDataDstFactory::DST_DX;

    gDstWidth = gSrc->FrameWidth();
    gDstHeight = gSrc->FrameHeight();
    if (gRotateLeft || gRotateRight)
    {
        gDstWidth = gSrc->FrameHeight();
        gDstHeight = gSrc->FrameWidth();
    }
    RgbDataDstFactory& fac = RgbDataDstFactory::Instance();
    gDst = fac.Construct(theDataDst, dstName, gDstWidth, gDstHeight);

    if (! gDst->Valid())
    {
        std::cout << "RgbDataDst failed" << std::endl;
        return 0;
    }
    gDst->WindowManage(0, 0);

    return DemoVideo();
}

} // namespace Video
} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::Video::mainVideo(argc, argv);
}

---