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

---

ExportKeyframes.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ExportKeyframes_h
#define Impala_Core_VideoSet_ExportKeyframes_h

#include "Persistency/ImageArchiveRepository.h"
#include "Persistency/FrameRepository.h"
#include "Core/Array/ImageArchiveMemory.h"
#include "Basis/FileName.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/Scale.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/ImageSet/MakeImageSet.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ExportKeyframes : public Listener
{
public:

    ExportKeyframes(Reporter* reporter, CmdOptions& options, VideoSet* vs)
    {
        mReporter = reporter;
        mKeyframes = 0;
        if (options.GetNrArg() < 6)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        // assumes that dirs in VideoSet and ImageSet are in "sync"
        // ImageSet is used for naming only
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        mImSet = Core::ImageSet::MakeImageSet(options.GetArg(2),
                                              vs->GetDatabase());
#else // REPOSITORY_USED
        mImSet = Core::ImageSet::MakeImageSet(options.GetArg(2));
#endif // REPOSITORY_USED
        if (!mImSet)
        {
            ILOG_ERROR("Image set was not constructed");
            return;
        }

        mScale = atof(options.GetArg(3));

        mArchive = false;
        mSplitArchive = false;
        if (options.GetArg(4) == "archive")
            mArchive = true;
        else if (options.GetArg(4) == "split")
            mSplitArchive = true;
        else if (options.GetArg(4) != "file")
            ILOG_ERROR("arg 4 should be file|archive|split");

        mForcePng = false;
        if (options.GetArg(5) == "png")
            mForcePng = true;
        else if (options.GetArg(5) != "jpg")
            ILOG_ERROR("arg 5 should be jpg|png");

        if (options.GetNrArg() > 6)
            Core::Array::gWriteJpgQuality = atol(options.GetArg(6));

        mBuf = 0;
        if (mArchive || mSplitArchive)
        {
            mBufSize = 10000000;
            mBuf = new char[mBufSize];
            mReporter->SetReportArray(false); // we will cause a "memory leak"
        }
    }

    virtual
    ~ExportKeyframes()
    {
        if (mBuf)
            delete mBuf;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, Keyframes* keyframes, bool* keyframeMask)
    {
        mKeyframes = keyframes;
        mCurKey = 0;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        mImSet->SetDatabase(vs->GetDatabase());
#endif // REPOSITORY_USED
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        mCurKey = mKeyframes->GetFirstKeyframeVideo(fileId);
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if ((mKeyframes->Get1(mCurKey) != fileId) ||
            (mKeyframes->Get3(mCurKey) != src->FrameNr()))
        {
            if (mKeyframes->Get1(mCurKey) != fileId)
                ILOG_ERROR("Wrong video: " << fileId << " instead of "
                           << mKeyframes->Get1(mCurKey));
            if (mKeyframes->Get3(mCurKey) != src->FrameNr())
                ILOG_ERROR("Wrong frame: " << src->FrameNr() << " instead of "
                           << mKeyframes->Get3(mCurKey) << " for keyId "
                           << mCurKey);
            //mCurKey++;
            //return;
        }
        typedef Array::Array2dVec3UInt8 ArrayT;
        ArrayT* im = Array::ArrayCreate<ArrayT>
            (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);
        ArrayT* sc = 0;
        if (mScale == 1.0)
            sc = im;
        else
            Array::Scale(sc, im, mScale, mScale, Geometry::NEAREST, true);
        if (mArchive || mSplitArchive)
        {
            size_t nrBytes = 0;
            String ext = FileNameExt(mImSet->GetFile(mCurKey));
            if ((ext == "png") || (mForcePng))
                Array::WritePngToMemory(sc, mBuf, mBufSize, &nrBytes);
            else
                Array::WriteJpgToMemory(sc, mBuf, mBufSize, &nrBytes);
            Array::Array2dScalarUInt8* data =
                Array::MakeFromData<Array::Array2dScalarUInt8>((UInt8*) mBuf,
                                                               nrBytes, 1);
            mImList.push_back(data);
        }
        else
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            String fName = mImSet->GetFilePathImageData(mCurKey, true, false);
            if (mForcePng) // warning : no protection from override
                fName = StringReplace(fName, ".jpg", ".png");
            if (fName.empty())
            {
                ILOG_ERROR("Empty filename");
            }
            else
            {
                if (FileNameExt(fName, true) == "jpg")
                    Array::WriteJpg(sc, fName, mImSet->GetDatabase());
                else
                    Array::WritePng(sc, fName, mImSet->GetDatabase());
            }
#else // REPOSITORY_USED
            String container = mImSet->GetContainerDirOfFile(mCurKey);
            String fName = mImSet->GetFile(mCurKey);
            if (mForcePng)
                fName = StringReplace(fName, ".jpg", ".png");
            Persistency::ImageLocator loc(vs->GetLocator(), container, fName);
            Persistency::ImageRepository().Add(loc, sc);
#endif // REPOSITORY_USED
        }
        if (sc != im)
            delete sc;
        delete im;
        mCurKey++;
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if (!mSplitArchive)
            return;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        int id = mImSet->GetFirstFileId(fileId); // use video as dir
        String fName = mImSet->GetFilePathImageArchive(id, "images.raw",
                                                       true, false);
        if (fName.empty())
            return;
        Array::WriteRawListVar(mImList, fName, mImSet->GetDatabase(), true, true);
#else // REPOSITORY_USED
        String container = mImSet->GetContainerDir(fileId); // use video as dir
        Persistency::ImageArchiveLocator loc(vs->GetLocator(), false,
                                             container, "images.raw", 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
#endif // REPOSITORY_USED
        Array::ArrayListDelete(&mImList);
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        if (!mArchive)
            return;
        String fName = mImSet->GetSetNameBase() + ".raw";
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        fName = mImSet->GetFilePathImageArchive(fName, true, false);
        if (fName.empty())
            return;
        ILOG_INFO("writing archive [" << fName << "]");
        Array::WriteRawListVar(mImList, fName, mImSet->GetDatabase(), true,
                               true);
#else // REPOSITORY_USED
        Persistency::ImageArchiveLocator loc(vs->GetLocator(), false,
                                             "", fName, 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
#endif // REPOSITORY_USED
        Array::ArrayListDelete(&mImList);
    }

private:

    Reporter*           mReporter;
    Keyframes*          mKeyframes;
    ImageSet::ImageSet* mImSet;
    int                 mCurKey;
    bool                mArchive;
    bool                mSplitArchive;
    bool                mForcePng;
    double              mScale;
    int                 mBufSize;
    char*               mBuf;
    std::vector<Array::Array2dScalarUInt8*> mImList;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ExportKeyframes, Impala.Core.VideoSet);

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

#endif

---