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

---

ExportFrames.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ExportFrames_h
#define Impala_Core_VideoSet_ExportFrames_h

#include "Persistency/ImageArchiveRepository.h"
#include "Persistency/FrameRepository.h"
#include "Core/Array/ImageArchiveMemory.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/Scale.h"
#include "Core/VideoSet/Reporter.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ExportFrames : public Listener
{
public:

    ExportFrames(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mSplitArchive = false;
        if (options.GetNrArg() > 2)
            if (options.GetArg(2) == "split")
                mSplitArchive = true;
        mJpg = false;
        if (options.GetNrArg() > 3)
            if (options.GetArg(3) == "jpg")
                mJpg = true;
        mScale = 1.0;
        if (options.GetNrArg() > 4)
            mScale = atof(options.GetArg(4));
        ILOG_INFO("scale = " << mScale);
        if (options.GetNrArg() > 5)
            Core::Array::gWriteJpgQuality = atol(options.GetArg(5));
        mBuf = 0;
        if (mSplitArchive)
        {
            mReporter->SetReportArray(false); // we will cause a "memory leak"
            mBufSize = 10000000;
            mBuf = new char[mBufSize];
        }
    }

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

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        HandleNewFrame(vs, fileId, src, Geometry::Rectangle(), "");
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src,
                   Geometry::Rectangle rect, String anno)
    {
        typedef Array::Array2dVec3UInt8 ArrayT;
        ArrayT* im = Array::ArrayCreate<ArrayT>
            (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);
        double scale = mScale;
        if (mScale > 1) // assume mScale indicates maximum width
        {
            scale = 1.0;
            while (scale * im->CW() > mScale)
                scale *= 0.5;
        }
        if (mSplitArchive)
        {
            size_t nrBytes = 0;
            ArrayT* sc = 0;
            Array::Scale(sc, im, scale, scale, Geometry::NEAREST, true);
            if (mJpg)
            {
                Array::WriteJpgToMemory(sc, mBuf, mBufSize, &nrBytes);
            }
            else
            {
                Array::WritePngToMemory(sc, mBuf, mBufSize, &nrBytes);
            }
            delete sc;
            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 = vs->GetFilePathFrames(fileId, src->FrameNr(),
                                                 ".png", true, false);
            if (fName.empty())
            {
                ILOG_ERROR("HandleNewFrame : Empty filename");
            }
            else
            {
                Array::WritePng(im, fName, vs->GetDatabase());
            }
#else // REPOSITORY_USED
            String container = vs->GetContainerFile(fileId);
            Persistency::FrameLocator loc(vs->GetLocator(), container,
                                          src->FrameNr(), ".png");
            Persistency::FrameRepository().Add(loc, im);
#endif // REPOSITORY_USED
        }
        delete im;
    }

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

private:

    Reporter* mReporter;
    bool      mSplitArchive;
    bool      mJpg;
    double    mScale;
    int       mBufSize;
    char*     mBuf;
    std::vector<Array::Array2dScalarUInt8*> mImList;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ExportFrames, Impala.Core.VideoSet);

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

#endif

---