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

---

ImageArchiveFileFset.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ImageArchiveFileFset_h
#define Impala_Core_Array_ImageArchiveFileFset_h

#include "Persistency/File.h"
#include "Core/Array/ImageArchive.h"
#include "Core/Array/ReadImage.h"

namespace Impala
{
namespace Core
{
namespace Array
{


class ImageArchiveFileFset : public ImageArchive
{
public:

    ImageArchiveFileFset(Persistency::File file)
    {
        mIOBuffer = 0;
        mFirstSegment = 0;

        if (!file.Valid())
        {
            ILOG_ERROR("Invalid file");
            return;
        }

        mIOBuffer = file.GetReadBuffer();
        if (!mIOBuffer)
            return;

        int bufSize = mIOBuffer->Size();
        int headerPos = bufSize - 16;
        char header[16];
        mIOBuffer->SetPosition(headerPos);
        mIOBuffer->Read(header, 16);
        if ((header[0] !=  'M') || (header[1] !=  'A') || (header[2] !=  'S')
            || (header[3] !=  'S') || (header[8] !=  'S') || (header[9] !=  'T')
            || (header[10] !=  'R') || (header[11] !=  'E'))
        {
            ILOG_ERROR("no magic header");
        }
        int nrEntries = GetIntFromChars(header, 4);
        int tabPos = bufSize - 16 - (12 * nrEntries);
        char* segmentTab = new char[12 * nrEntries];
        mIOBuffer->SetPosition(tabPos);
        mIOBuffer->Read(segmentTab, 12 * nrEntries);

        int offset = 0;
        for (int i=0 ; i<nrEntries ; i++)
        {
            int segId = GetIntFromChars(segmentTab, i*12);
            mSegmentId.push_back(segId);

            int segLen = GetIntFromChars(segmentTab, i*12 + 4);
            mSegmentLength.push_back(segLen);

            int compressed = GetIntFromChars(segmentTab, i*12 + 8);
            mCompressed.push_back(compressed);

            mFileOffset.push_back(offset);
            offset += segLen - compressed;
        }

        mFirstSegment = GetSegmentBuf(0);

        delete segmentTab;
    }

    virtual
    ~ImageArchiveFileFset()
    {
        if (mIOBuffer)
            delete mIOBuffer;
        if (mFirstSegment)
            delete mFirstSegment;
    }

    bool
    Valid()
    {
        return (mIOBuffer != 0) && (mFileOffset.size() != 0);
    }

    int
    NrImages()
    {
        return mFileOffset.size();
    }

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

        Array2dVec3UInt8* im = 0;
        char* data = GetSegmentBuf(idx);
        ReadImageFromMemory(im, data, mSegmentLength[idx]);
        delete data;

        return im;
    }

private:

    int
    GetIntFromChars(char* buf, int pos)
    {
        int a0 = buf[pos + 0] & 0xff;
        int a1 = buf[pos + 1] & 0xff;
        int a2 = buf[pos + 2] & 0xff;
        int a3 = buf[pos + 3] & 0xff;
        int res = a0 << 24 | a1 << 16 | a2 << 8 | a3;
        return res;
    }

    char*
    GetSegmentBuf(int idx)
    {
        int segLen = mSegmentLength[idx];
        char* res = new char[segLen];
        int compressed = mCompressed[idx];
        if (compressed > 0)
            memcpy(res, mFirstSegment, compressed);
        int remainder = segLen - compressed;
        if (remainder > 0)
        {
            int off = mFileOffset[idx];
            mIOBuffer->SetPosition(off);
            mIOBuffer->Read(res + compressed, remainder);
        }
        return res;
    }


    Util::IOBuffer*  mIOBuffer;
    std::vector<int> mSegmentId;
    std::vector<int> mSegmentLength;
    std::vector<int> mCompressed;
    std::vector<int> mFileOffset;
    char*            mFirstSegment;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageArchiveFileFset, Impala.Core.Array);

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

#endif

---