///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2011, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// *       Neither the name of Industrial Light & Magic nor the names of

// its contributors may be used to endorse or promote products derived

// from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

///////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------

//

//      class DeepTiledInputFile

//

//-----------------------------------------------------------------------------

#include <ImfDeepTiledInputFile.h>

#include <ImfTileDescriptionAttribute.h>

#include <ImfChannelList.h>

#include <ImfMisc.h>

#include <ImfTiledMisc.h>

#include <ImfStdIO.h>

#include <ImfCompressor.h>

#include "ImathBox.h"

#include <ImfXdr.h>

#include <ImfConvert.h>

#include <ImfVersion.h>

#include <ImfTileOffsets.h>

#include <ImfThreading.h>

#include <ImfPartType.h>

#include <ImfMultiPartInputFile.h>

#include "IlmThreadPool.h"

#include "IlmThreadSemaphore.h"

#include "IlmThreadMutex.h"

#include "ImfInputStreamMutex.h"

#include "ImfInputPartData.h"

#include "ImathVec.h"

#include "Iex.h"

#include <string>

#include <vector>

#include <algorithm>

#include <assert.h>

#include <limits>

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::V2i;

using std::string;

using std::vector;

using std::min;

using std::max;

using ILMTHREAD_NAMESPACE::Mutex;

using ILMTHREAD_NAMESPACE::Lock;

using ILMTHREAD_NAMESPACE::Semaphore;

using ILMTHREAD_NAMESPACE::Task;

using ILMTHREAD_NAMESPACE::TaskGroup;

using ILMTHREAD_NAMESPACE::ThreadPool;

namespace {

struct TInSliceInfo

{

    PixelType           typeInFrameBuffer;

    PixelType           typeInFile;

    char*               pointerArrayBase;

    size_t              xStride;

    size_t              yStride;

    ptrdiff_t           sampleStride;

    bool                fill;

    bool                skip;

    double              fillValue;

    int                 xTileCoords;

    int                 yTileCoords;

    TInSliceInfo (PixelType typeInFrameBuffer = HALF,

                  char * base = NULL,

                  PixelType typeInFile = HALF,

                  size_t xStride = 0,

                  size_t yStride = 0,

                  ptrdiff_t sampleStride = 0,

                  bool fill = false,

                  bool skip = false,

                  double fillValue = 0.0,

                  int xTileCoords = 0,

                  int yTileCoords = 0);

};

TInSliceInfo::TInSliceInfo (PixelType tifb,

                            char * b,

                            PixelType tifl,

                            size_t xs, size_t ys,

                            ptrdiff_t spst,

                            bool f, bool s,

                            double fv,

                            int xtc,

                            int ytc)

:

    typeInFrameBuffer (tifb),

    typeInFile (tifl),

    pointerArrayBase (b),

    xStride (xs),

    yStride (ys),

    sampleStride (spst),

    fill (f),

    skip (s),

    fillValue (fv),

    xTileCoords (xtc),

    yTileCoords (ytc)

{

    // empty

}

struct TileBuffer

{

    Array2D<unsigned int>       sampleCount;

    const char *                uncompressedData;

    char *                      buffer;

    Int64                         dataSize;

    Int64                         uncompressedDataSize;

    Compressor *                compressor;

    Compressor::Format          format;

    int                         dx;

    int                         dy;

    int                         lx;

    int                         ly;

    bool                        hasException;

    string                      exception;

     TileBuffer ();

    ~TileBuffer ();

    inline void         wait () {_sem.wait();}

    inline void         post () {_sem.post();}

 protected:

    Semaphore _sem;

};

TileBuffer::TileBuffer ():

    uncompressedData (0),

    buffer (0),

    dataSize (0),

    compressor (0),

    format (defaultFormat (compressor)),

    dx (-1),

    dy (-1),

    lx (-1),

    ly (-1),

    hasException (false),

    exception (),

    _sem (1)

{

    // empty

}

TileBuffer::~TileBuffer ()

{

    delete compressor;

}

} // namespace

class MultiPartInputFile;

//

// struct TiledInputFile::Data stores things that will be

// needed between calls to readTile()

//

struct DeepTiledInputFile::Data: public Mutex

{

    Header          header;                         // the image header

    TileDescription tileDesc;                       // describes the tile layout

    int             version;                        // file's version

    DeepFrameBuffer frameBuffer;                    // framebuffer to write into

    LineOrder       lineOrder;                      // the file's lineorder

    int             minX;                           // data window's min x coord

    int             maxX;                           // data window's max x coord

    int             minY;                           // data window's min y coord

    int             maxY;                           // data window's max x coord

    int             numXLevels;                     // number of x levels

    int             numYLevels;                     // number of y levels

    int *           numXTiles;                      // number of x tiles at a level

    int *           numYTiles;                      // number of y tiles at a level

    TileOffsets     tileOffsets;                    // stores offsets in file for

    // each tile

    bool            fileIsComplete;                 // True if no tiles are missing

                                                    // in the file

    vector<TInSliceInfo*> slices;                    // info about channels in file

                                                    // ourselves? or does someone

                                                    // else do it?

    int             partNumber;                     // part number

    bool            multiPartBackwardSupport;       // if we are reading a multipart file

                                                    // using OpenEXR 1.7 API

    int             numThreads;                     // number of threads

    MultiPartInputFile* multiPartFile;              // the MultiPartInputFile used to

                                                    // support backward compatibility

    vector<TileBuffer*> tileBuffers;                // each holds a single tile

    bool            memoryMapped;                   // if the stream is memory mapped

    char*           sampleCountSliceBase;           // pointer to the start of

                                                    // the sample count array

    ptrdiff_t       sampleCountXStride;             // x stride of the sample count array

    ptrdiff_t       sampleCountYStride;             // y stride of the sample count array

    int             sampleCountXTileCoords;         // the value of xTileCoords from the

                                                    // sample count slice

    int             sampleCountYTileCoords;         // the value of yTileCoords from the

                                                    // sample count slice

    Array<char>     sampleCountTableBuffer;         // the buffer for sample count table

    Compressor*     sampleCountTableComp;           // the decompressor for sample count table

    Int64           maxSampleCountTableSize;        // the max size in bytes for a pixel

                                                    // sample count table

    int             combinedSampleSize;             // total size of all channels combined to check sampletable size

    InputStreamMutex *  _streamData;

    bool                _deleteStream; // should we delete the stream

     Data (int numThreads);

    ~Data ();

    inline TileBuffer * getTileBuffer (int number);

                                                    // hash function from tile indices

                                                    // into our vector of tile buffers

    int&                getSampleCount(int x, int y);

                                                    // get the number of samples

                                                    // in each pixel

};

DeepTiledInputFile::Data::Data (int numThreads):

    numXTiles (0),

    numYTiles (0),

    partNumber (-1),

    multiPartBackwardSupport(false),

    numThreads(numThreads),

    memoryMapped(false),

    _streamData(NULL),

    _deleteStream(false)

{

    //

    // We need at least one tileBuffer, but if threading is used,

    // to keep n threads busy we need 2*n tileBuffers

    //

    tileBuffers.resize (max (1, 2 * numThreads));

}

DeepTiledInputFile::Data::~Data ()

{

    delete [] numXTiles;

    delete [] numYTiles;

    for (size_t i = 0; i < tileBuffers.size(); i++)

        delete tileBuffers[i];

    if (multiPartBackwardSupport)

        delete multiPartFile;

    for (size_t i = 0; i < slices.size(); i++)

        delete slices[i];

}

TileBuffer*

DeepTiledInputFile::Data::getTileBuffer (int number)

{

    return tileBuffers[number % tileBuffers.size()];

}

int&

DeepTiledInputFile::Data::getSampleCount(int x, int y)

{

    return sampleCount(sampleCountSliceBase,

                       sampleCountXStride,

                       sampleCountYStride,

                       x, y);

}

namespace {

void

readTileData (InputStreamMutex *streamData,

              DeepTiledInputFile::Data *ifd,

              int dx, int dy,

              int lx, int ly,

              char *&buffer,

              Int64 &dataSize,

              Int64 &unpackedDataSize)

{

    //

    // Read a single tile block from the file and into the array pointed

    // to by buffer.  If the file is memory-mapped, then we change where

    // buffer points instead of writing into the array (hence buffer needs

    // to be a reference to a char *).

    //

    //

    // Look up the location for this tile in the Index and

    // seek to that position if necessary

    //

    Int64 tileOffset = ifd->tileOffsets (dx, dy, lx, ly);

    if (tileOffset == 0)

    {

        THROW (IEX_NAMESPACE::InputExc, "Tile (" << dx << ", " << dy << ", " <<

                              lx << ", " << ly << ") is missing.");

    }

    //

    // In a multi-part file, the next chunk does not need to

    // belong to the same part, so we have to compare the

    // offset here.

    //

    if ( !isMultiPart(ifd->version) )

    {

        if (streamData->currentPosition != tileOffset)

            streamData->is->seekg(tileOffset);

    }

    else

    {

        //

        // In a multi-part file, the file pointer may be moved by other

        // parts, so we have to ask tellg() where we are.

        //

        if (streamData->is->tellg() != tileOffset)

            streamData->is->seekg (tileOffset);

    }

    //

    // Read the first few bytes of the tile (the header).

    // Verify that the tile coordinates and the level number

    // are correct.

    //

    int tileXCoord, tileYCoord, levelX, levelY;

    if (isMultiPart(ifd->version))

    {

        int partNumber;

        Xdr::read <StreamIO> (*streamData->is, partNumber);

        if (partNumber != ifd->partNumber)

        {

            THROW (IEX_NAMESPACE::ArgExc, "Unexpected part number " << partNumber

                   << ", should be " << ifd->partNumber << ".");

        }

    }

    Xdr::read <StreamIO> (*streamData->is, tileXCoord);

    Xdr::read <StreamIO> (*streamData->is, tileYCoord);

    Xdr::read <StreamIO> (*streamData->is, levelX);

    Xdr::read <StreamIO> (*streamData->is, levelY);

    Int64 tableSize;

    Xdr::read <StreamIO> (*streamData->is, tableSize);

    Xdr::read <StreamIO> (*streamData->is, dataSize);

    Xdr::read <StreamIO> (*streamData->is, unpackedDataSize);

    //

    // Skip the pixel sample count table because we have read this data.

    //

    Xdr::skip <StreamIO> (*streamData->is, tableSize);

    if (tileXCoord != dx)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile x coordinate.");

    if (tileYCoord != dy)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile y coordinate.");

    if (levelX != lx)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile x level number coordinate.");

    if (levelY != ly)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile y level number coordinate.");

    //

    // Read the pixel data.

    //

    if (streamData->is->isMemoryMapped ())

        buffer = streamData->is->readMemoryMapped (dataSize);

    else

    {

        // (TODO) check if the packed data size is too big?

        // (TODO) better memory management here. Don't delete buffer everytime.

        if (buffer != 0) delete[] buffer;

        buffer = new char[dataSize];

        streamData->is->read (buffer, dataSize);

    }

    //

    // Keep track of which tile is the next one in

    // the file, so that we can avoid redundant seekg()

    // operations (seekg() can be fairly expensive).

    //

    streamData->currentPosition = tileOffset + 4 * Xdr::size<int>() +

                                  3 * Xdr::size<Int64>()            +

                                  tableSize                         +

                                  dataSize;

}

void

readNextTileData (InputStreamMutex *streamData,

                  DeepTiledInputFile::Data *ifd,

                  int &dx, int &dy,

                  int &lx, int &ly,

                  char * & buffer,

                  Int64 &dataSize,

                  Int64 &unpackedDataSize)

{

    //

    // Read the next tile block from the file

    //

    //

    // Read the first few bytes of the tile (the header).

    //

    Xdr::read <StreamIO> (*streamData->is, dx);

    Xdr::read <StreamIO> (*streamData->is, dy);

    Xdr::read <StreamIO> (*streamData->is, lx);

    Xdr::read <StreamIO> (*streamData->is, ly);

    Int64 tableSize;

    Xdr::read <StreamIO> (*streamData->is, tableSize);

    Xdr::read <StreamIO> (*streamData->is, dataSize);

    Xdr::read <StreamIO> (*streamData->is, unpackedDataSize);

    //

    // Skip the pixel sample count table because we have read this data.

    //

    Xdr::skip <StreamIO> (*streamData->is, tableSize);

    //

    // Read the pixel data.

    //

    streamData->is->read (buffer, dataSize);

    //

    // Keep track of which tile is the next one in

    // the file, so that we can avoid redundant seekg()

    // operations (seekg() can be fairly expensive).

    //

    streamData->currentPosition += 4 * Xdr::size<int>()   +

                                   3 * Xdr::size<Int64>() +

                                   tableSize              +

                                   dataSize;

}

//

// A TileBufferTask encapsulates the task of uncompressing

// a single tile and copying it into the frame buffer.

//

class TileBufferTask : public Task

{

  public:

    TileBufferTask (TaskGroup *group,

                    DeepTiledInputFile::Data *ifd,

                    TileBuffer *tileBuffer);

    virtual ~TileBufferTask ();

    virtual void                execute ();

  private:

    DeepTiledInputFile::Data *      _ifd;

    TileBuffer *                _tileBuffer;

};

TileBufferTask::TileBufferTask

    (TaskGroup *group,

     DeepTiledInputFile::Data *ifd,

     TileBuffer *tileBuffer)

:

    Task (group),

    _ifd (ifd),

    _tileBuffer (tileBuffer)

{

    // empty

}

TileBufferTask::~TileBufferTask ()

{

    //

    // Signal that the tile buffer is now free

    //

    _tileBuffer->post ();

}

void

TileBufferTask::execute ()

{

    try

    {

        //

        // Calculate information about the tile

        //

        Box2i tileRange = OPENEXR_IMF_INTERNAL_NAMESPACE::dataWindowForTile (

                _ifd->tileDesc,

                _ifd->minX, _ifd->maxX,

                _ifd->minY, _ifd->maxY,

                _tileBuffer->dx,

                _tileBuffer->dy,

                _tileBuffer->lx,

                _tileBuffer->ly);

        //

        // Get the size of the tile.

        //

        Array<unsigned int> numPixelsPerScanLine;

        numPixelsPerScanLine.resizeErase(tileRange.max.y - tileRange.min.y + 1);

        int sizeOfTile = 0;

        int maxBytesPerTileLine = 0;

        for (int y = tileRange.min.y; y <= tileRange.max.y; y++)

        {

            numPixelsPerScanLine[y - tileRange.min.y] = 0;

            int bytesPerLine = 0;

            for (int x = tileRange.min.x; x <= tileRange.max.x; x++)

            {

                int xOffset = _ifd->sampleCountXTileCoords * tileRange.min.x;

                int yOffset = _ifd->sampleCountYTileCoords * tileRange.min.y;

                int count = _ifd->getSampleCount(x - xOffset, y - yOffset);

                for (unsigned int c = 0; c < _ifd->slices.size(); ++c)

                {

                    sizeOfTile += count * pixelTypeSize(_ifd->slices[c]->typeInFile);

                    bytesPerLine += count * pixelTypeSize(_ifd->slices[c]->typeInFile);

                }

                numPixelsPerScanLine[y - tileRange.min.y] += count;

            }

            if (bytesPerLine > maxBytesPerTileLine)

                maxBytesPerTileLine = bytesPerLine;

        }

        // (TODO) don't do this every time.

        if (_tileBuffer->compressor != 0)

            delete _tileBuffer->compressor;

        _tileBuffer->compressor = newTileCompressor

                                  (_ifd->header.compression(),

                                   maxBytesPerTileLine,

                                   _ifd->tileDesc.ySize,

                                   _ifd->header);

        //

        // Uncompress the data, if necessary

        //

        if (_tileBuffer->compressor && _tileBuffer->dataSize < Int64(sizeOfTile))

        {

            _tileBuffer->format = _tileBuffer->compressor->format();

            _tileBuffer->dataSize = _tileBuffer->compressor->uncompressTile

                (_tileBuffer->buffer, _tileBuffer->dataSize,

                 tileRange, _tileBuffer->uncompressedData);

        }

        else

        {

            //

            // If the line is uncompressed, it's in XDR format,

            // regardless of the compressor's output format.

            //

            _tileBuffer->format = Compressor::XDR;

            _tileBuffer->uncompressedData = _tileBuffer->buffer;

        }

        //

        // Convert the tile of pixel data back from the machine-independent

        // representation, and store the result in the frame buffer.

        //

        const char *readPtr = _tileBuffer->uncompressedData;

                                                        // points to where we

                                                        // read from in the

                                                        // tile block

        //

        // Iterate over the scan lines in the tile.

        //

        for (int y = tileRange.min.y; y <= tileRange.max.y; ++y)

        {

            //

            // Iterate over all image channels.

            //

            for (unsigned int i = 0; i < _ifd->slices.size(); ++i)

            {

                TInSliceInfo &slice = *_ifd->slices[i];

                //

                // These offsets are used to facilitate both

                // absolute and tile-relative pixel coordinates.

                //

                int xOffsetForData = (slice.xTileCoords == 0) ? 0 : tileRange.min.x;

                int yOffsetForData = (slice.yTileCoords == 0) ? 0 : tileRange.min.y;

                int xOffsetForSampleCount =

                        (_ifd->sampleCountXTileCoords == 0) ? 0 : tileRange.min.x;

                int yOffsetForSampleCount =

                        (_ifd->sampleCountYTileCoords == 0) ? 0 : tileRange.min.y;

                //

                // Fill the frame buffer with pixel data.

                //

                if (slice.skip)

                {

                    //

                    // The file contains data for this channel, but

                    // the frame buffer contains no slice for this channel.

                    //

                    skipChannel (readPtr, slice.typeInFile,

                                 numPixelsPerScanLine[y - tileRange.min.y]);

                }

                else

                {

                    //

                    // The frame buffer contains a slice for this channel.

                    //

                    copyIntoDeepFrameBuffer (readPtr, slice.pointerArrayBase,

                                             _ifd->sampleCountSliceBase,

                                             _ifd->sampleCountXStride,

                                             _ifd->sampleCountYStride,

                                             y,

                                             tileRange.min.x,

                                             tileRange.max.x,

                                             xOffsetForSampleCount, yOffsetForSampleCount,

                                             xOffsetForData, yOffsetForData,

                                             slice.sampleStride, 

                                             slice.xStride,

                                             slice.yStride,

                                             slice.fill,

                                             slice.fillValue, _tileBuffer->format,

                                             slice.typeInFrameBuffer,

                                             slice.typeInFile);

                }

            }

        }

    }

    catch (std::exception &e)

    {

        if (!_tileBuffer->hasException)

        {

            _tileBuffer->exception = e.what ();

            _tileBuffer->hasException = true;

        }

    }

    catch (...)

    {

        if (!_tileBuffer->hasException)

        {

            _tileBuffer->exception = "unrecognized exception";

            _tileBuffer->hasException = true;

        }

    }

}

TileBufferTask *

newTileBufferTask

    (TaskGroup *group,

     DeepTiledInputFile::Data *ifd,

     int number,

     int dx, int dy,

     int lx, int ly)

{

    //

    // Wait for a tile buffer to become available,

    // fill the buffer with raw data from the file,

    // and create a new TileBufferTask whose execute()

    // method will uncompress the tile and copy the

    // tile's pixels into the frame buffer.

    //

    TileBuffer *tileBuffer = ifd->getTileBuffer (number);

    try

    {

        tileBuffer->wait();

        tileBuffer->dx = dx;

        tileBuffer->dy = dy;

        tileBuffer->lx = lx;

        tileBuffer->ly = ly;

        tileBuffer->uncompressedData = 0;

        readTileData (ifd->_streamData, ifd, dx, dy, lx, ly,

                      tileBuffer->buffer,

                      tileBuffer->dataSize,

                      tileBuffer->uncompressedDataSize);

    }

    catch (...)

    {

        //

        // Reading from the file caused an exception.

        // Signal that the tile buffer is free, and

        // re-throw the exception.

        //

        tileBuffer->post();

        throw;

    }

    return new TileBufferTask (group, ifd, tileBuffer);

}

} // namespace

DeepTiledInputFile::DeepTiledInputFile (const char fileName[], int numThreads):

    _data (new Data (numThreads))

{

    _data->_deleteStream=true;

    //

    // This constructor is called when a user

    // explicitly wants to read a tiled file.

    //

    IStream* is = 0;

    try

    {

        is = new StdIFStream (fileName);

        readMagicNumberAndVersionField(*is, _data->version);

        //

        // Compatibility to read multpart file.

        //

        if (isMultiPart(_data->version))

        {

            compatibilityInitialize(*is);

        }

        else

        {

            _data->_streamData = new InputStreamMutex();

            _data->_streamData->is = is;

            _data->header.readFrom (*_data->_streamData->is, _data->version);

            initialize();

            _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,true);

            _data->_streamData->currentPosition = _data->_streamData->is->tellg();

        }

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (is)          delete is;

        if (_data && !_data->multiPartBackwardSupport && _data->_streamData) delete _data->_streamData;

        if (_data)       delete _data;

        REPLACE_EXC (e, "Cannot open image file "

                        "\"" << fileName << "\". " << e);

        throw;

    }

    catch (...)

    {

        if (is)          delete is;

        if (_data && !_data->multiPartBackwardSupport && _data->_streamData) delete _data->_streamData;

        if (_data)       delete _data;

        throw;

    }

}

DeepTiledInputFile::DeepTiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads):

    _data (new Data (numThreads))

{

    _data->_streamData=0;

    _data->_deleteStream=false;

    //

    // This constructor is called when a user

    // explicitly wants to read a tiled file.

    //

    try

    {

        readMagicNumberAndVersionField(is, _data->version);

        //

        // Backward compatibility to read multpart file.

        //

        if (isMultiPart(_data->version))

        {

            compatibilityInitialize(is);

        }

        else

        {

            _data->_streamData = new InputStreamMutex();

            _data->_streamData->is = &is;

            _data->header.readFrom (*_data->_streamData->is, _data->version);

            initialize();

            // file is guaranteed not to be multipart, but is deep

            _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete, false,true);

            _data->memoryMapped = _data->_streamData->is->isMemoryMapped();

            _data->_streamData->currentPosition = _data->_streamData->is->tellg();

        }

    }

    catch (IEX_NAMESPACE::BaseExc &e)