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

---

ImageArchiveMapi.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ImageArchiveMapi_h
#define Impala_Core_Array_ImageArchiveMapi_h

#include "Core/Array/ImageArchive.h"
#include "Link/Monet/Connection.h"
#include "Basis/Quid.h"
#include "Util/BinHex.h"
#include "Core/Array/ReadImage.h"

namespace Impala
{
namespace Core
{
namespace Array
{


class ImageArchiveMapi : public ImageArchive
{
public:

    ImageArchiveMapi(Quid vidQuid, Link::Monet::Connection* conn)
    {
        Init(vidQuid, conn);
    }

    virtual
    ~ImageArchiveMapi()
    {
        if (mFrameImageId)
            delete mFrameImageId;
    }

    bool
    Valid()
    {
        return mConn->Valid() && (NrImages() != 0);
    }

    int
    NrImages()
    {
        return mNrImages;
    }

    Array2dVec3UInt8*
    ReadImage(int idx)
    {
        if (!Valid())
        {
            ILOG_ERROR("Cannot ReadImage: archive not valid");
            return 0;
        }

        size_t blockSize = 0;
        UInt8* data = GetImageData(idx, blockSize);
        Array2dVec3UInt8* im = 0;
        ReadImageFromMemory(im, (char*) data, blockSize);
        delete data;
        return im;
    }

    UInt8*
    GetImageData(int idx, size_t& blockSize)
    {
        if (!Valid())
        {
            ILOG_ERROR("Cannot GetImageData: archive not valid");
            return 0;
        }
        if ((idx < 0) || (idx >= mNrImages))
        {
            ILOG_ERROR("GetImageData: idx out of range");
            return 0;
        }

        String query = "select image from frame_image where frame_image_id = "
            + MakeString(mFrameImageId[idx]) + ";";

        MapiHdl hdl = mConn->QueryPartStart(query);
        if (hdl == 0)
            return 0;

        std::vector<String> res;
        if (!mConn->QueryPartFetchString(hdl, 0, res))
            return 0;

        mConn->QueryPartEnd(hdl);
        if (res.size() != 1)
        {
            ILOG_ERROR("GetImageData: unexpected number of results");
            return 0;
        }
        return Util::Hex2Bin(res[0], blockSize);
    }

private:

    void
    Init(Quid vidQuid, Link::Monet::Connection* conn)
    {
        mConn = conn;
        mNrImages = 0;
        mFrameImageId = 0;

        if ((conn == 0) || (!conn->Valid()))
        {
            ILOG_ERROR("No valid connection given");
            return;
        }
        if (!QuidValid(vidQuid))
        {
            ILOG_ERROR("Invalid video Quid");
            return;
        }

        String query =
            "select fi.frame_image_id \
             from   frame_image fi, fragment f, media m \
             where  m.identifier = " + MakeString(vidQuid) + " and \
                    f.media_id = m.media_id and \
                    fi.fragment_id = f.fragment_id \
             order by f.fragment_start;";

        MapiHdl hdl = mConn->QueryPartStart(query);
        if (hdl == 0)
            return;

        if (!mConn->QueryPartFetchInt(hdl, 0, mFrameImageId, mNrImages))
            return;

        conn->QueryPartEnd(hdl);
    }

    Link::Monet::Connection* mConn;
    int  mNrImages;
    int* mFrameImageId;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageArchiveMapi, Impala.Core.Array);

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---