rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfInputFile.cpp

@@ -0,0 +1,895 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, 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 InputFile
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfInputFile.h"
+#include "ImfScanLineInputFile.h"
+#include "ImfTiledInputFile.h"
+#include "ImfChannelList.h"
+#include "ImfMisc.h"
+#include "ImfStdIO.h"
+#include "ImfVersion.h"
+#include "ImfPartType.h"
+#include "ImfInputPartData.h"
+#include "ImfMultiPartInputFile.h"
+
+#include <ImfCompositeDeepScanLine.h>
+#include <ImfDeepScanLineInputFile.h>
+
+#include "ImathFun.h"
+#include "IlmThreadMutex.h"
+#include "Iex.h"
+#include "half.h"
+
+#include <fstream>
+#include <algorithm>
+
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+
+using IMATH_NAMESPACE::Box2i;
+using IMATH_NAMESPACE::divp;
+using IMATH_NAMESPACE::modp;
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::Lock;
+
+
+//
+// Struct InputFile::Data stores things that will be
+// needed between calls to readPixels
+//
+
+struct InputFile::Data : public Mutex
+{
+    Header              header;
+    int                 version;
+    bool                isTiled;
+
+    TiledInputFile *	tFile;
+    ScanLineInputFile *	sFile;
+    DeepScanLineInputFile * dsFile;
+
+    LineOrder		lineOrder;      // the file's lineorder
+    int			minY;           // data window's min y coord
+    int			maxY;           // data window's max x coord
+    
+    FrameBuffer		tFileBuffer; 
+    FrameBuffer *	cachedBuffer;
+    CompositeDeepScanLine * compositor; // for loading deep files
+    
+    int			cachedTileY;
+    int                 offset;
+    
+    int                 numThreads;
+
+    int                 partNumber;
+    InputPartData*      part;
+
+    bool                multiPartBackwardSupport;
+    MultiPartInputFile* multiPartFile;
+    InputStreamMutex    * _streamData;
+    bool                _deleteStream;
+
+     Data (int numThreads);
+    ~Data ();
+
+    void		deleteCachedBuffer();
+};
+
+
+InputFile::Data::Data (int numThreads):
+    isTiled (false),
+    tFile (0),
+    sFile (0),
+    dsFile(0),
+    cachedBuffer (0),
+    compositor(0),
+    cachedTileY (-1),
+    numThreads (numThreads),
+    partNumber (-1),
+    part(NULL),
+    multiPartBackwardSupport (false),
+    multiPartFile (0),
+    _streamData(0),
+    _deleteStream(false)
+           
+{
+    // empty
+}
+
+
+InputFile::Data::~Data ()
+{
+    if (tFile)
+        delete tFile;
+    if (sFile)
+        delete sFile;
+    if (dsFile)
+        delete dsFile;
+    if (compositor)
+        delete compositor;
+
+    deleteCachedBuffer();
+
+    if (multiPartBackwardSupport && multiPartFile)
+        delete multiPartFile;
+}
+
+
+void	
+InputFile::Data::deleteCachedBuffer()
+{
+    //
+    // Delete the cached frame buffer, and all memory
+    // allocated for the slices in the cached frameBuffer.
+    //
+
+    if (cachedBuffer)
+    {
+	for (FrameBuffer::Iterator k = cachedBuffer->begin();
+	     k != cachedBuffer->end();
+	     ++k)
+	{
+	    Slice &s = k.slice();
+
+	    switch (s.type)
+	    {
+	      case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:
+
+		delete [] (((unsigned int *)s.base) + offset);
+		break;
+
+	      case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:
+
+		delete [] ((half *)s.base + offset);
+		break;
+
+	      case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:
+
+		delete [] (((float *)s.base) + offset);
+		break;
+              case NUM_PIXELTYPES :
+                  throw(IEX_NAMESPACE::ArgExc("Invalid pixel type"));
+	    }                
+	}
+
+	//
+	// delete the cached frame buffer
+	//
+
+	delete cachedBuffer;
+	cachedBuffer = 0;
+    }
+}
+
+
+namespace {
+
+void
+bufferedReadPixels (InputFile::Data* ifd, int scanLine1, int scanLine2)
+{
+    //
+    // bufferedReadPixels reads each row of tiles that intersect the
+    // scan-line range (scanLine1 to scanLine2). The previous row of
+    // tiles is cached in order to prevent redundent tile reads when
+    // accessing scanlines sequentially.
+    //
+
+    int minY = std::min (scanLine1, scanLine2);
+    int maxY = std::max (scanLine1, scanLine2);
+
+    if (minY < ifd->minY || maxY >  ifd->maxY)
+    {
+        throw IEX_NAMESPACE::ArgExc ("Tried to read scan line outside "
+			   "the image file's data window.");
+    }
+
+    //
+    // The minimum and maximum y tile coordinates that intersect this
+    // scanline range
+    //
+
+    int minDy = (minY - ifd->minY) / ifd->tFile->tileYSize();
+    int maxDy = (maxY - ifd->minY) / ifd->tFile->tileYSize();
+
+    //
+    // Figure out which one is first in the file so we can read without seeking
+    //
+
+    int yStart, yEnd, yStep;
+
+    if (ifd->lineOrder == DECREASING_Y)
+    {
+        yStart = maxDy;
+        yEnd = minDy - 1;
+        yStep = -1;
+    }
+    else
+    {
+        yStart = minDy;
+        yEnd = maxDy + 1;
+        yStep = 1;
+    }
+
+    //
+    // the number of pixels in a row of tiles
+    //
+
+    Box2i levelRange = ifd->tFile->dataWindowForLevel(0);
+    
+    //
+    // Read the tiles into our temporary framebuffer and copy them into
+    // the user's buffer
+    //
+
+    for (int j = yStart; j != yEnd; j += yStep)
+    {
+        Box2i tileRange = ifd->tFile->dataWindowForTile (0, j, 0);
+
+        int minYThisRow = std::max (minY, tileRange.min.y);
+        int maxYThisRow = std::min (maxY, tileRange.max.y);
+
+        if (j != ifd->cachedTileY)
+        {
+            //
+            // We don't have any valid buffered info, so we need to read in
+            // from the file.
+            //
+
+            ifd->tFile->readTiles (0, ifd->tFile->numXTiles (0) - 1, j, j);
+            ifd->cachedTileY = j;
+        }
+
+        //
+        // Copy the data from our cached framebuffer into the user's
+        // framebuffer.
+        //
+
+        for (FrameBuffer::ConstIterator k = ifd->cachedBuffer->begin();
+             k != ifd->cachedBuffer->end();
+             ++k)
+        {
+            Slice fromSlice = k.slice();		// slice to write from
+            Slice toSlice = ifd->tFileBuffer[k.name()];	// slice to write to
+
+            char *fromPtr, *toPtr;
+            int size = pixelTypeSize (toSlice.type);
+
+	    int xStart = levelRange.min.x;
+	    int yStart = minYThisRow;
+
+	    while (modp (xStart, toSlice.xSampling) != 0)
+		++xStart;
+
+	    while (modp (yStart, toSlice.ySampling) != 0)
+		++yStart;
+
+            for (int y = yStart;
+		 y <= maxYThisRow;
+		 y += toSlice.ySampling)
+            {
+		//
+                // Set the pointers to the start of the y scanline in
+                // this row of tiles
+		//
+                
+                fromPtr = fromSlice.base +
+                          (y - tileRange.min.y) * fromSlice.yStride +
+                          xStart * fromSlice.xStride;
+
+                toPtr = toSlice.base +
+                        divp (y, toSlice.ySampling) * toSlice.yStride +
+                        divp (xStart, toSlice.xSampling) * toSlice.xStride;
+
+		//
+                // Copy all pixels for the scanline in this row of tiles
+		//
+
+                for (int x = xStart;
+		     x <= levelRange.max.x;
+		     x += toSlice.xSampling)
+                {
+		    for (int i = 0; i < size; ++i)
+			toPtr[i] = fromPtr[i];
+
+		    fromPtr += fromSlice.xStride * toSlice.xSampling;
+		    toPtr += toSlice.xStride;
+                }
+            }
+        }
+    }
+}
+
+} // namespace
+
+
+
+InputFile::InputFile (const char fileName[], int numThreads):
+    _data (new Data (numThreads))
+{
+    _data->_streamData = NULL;
+    _data->_deleteStream=true;
+    
+    OPENEXR_IMF_INTERNAL_NAMESPACE::IStream* is = 0;
+    try
+    {
+        is = new StdIFStream (fileName);
+        readMagicNumberAndVersionField(*is, _data->version);
+
+        //
+        // compatibility to read multipart file.
+        //
+        if (isMultiPart(_data->version))
+        {
+            compatibilityInitialize(*is);
+        }
+        else
+        {
+            _data->_streamData = new InputStreamMutex();
+            _data->_streamData->is = is;
+            _data->header.readFrom (*_data->_streamData->is, _data->version);
+            
+            // fix type attribute in single part regular image types
+            // (may be wrong if an old version of OpenEXR converts
+            // a tiled image to scanline or vice versa)
+            if(!isNonImage(_data->version)  && 
+               !isMultiPart(_data->version) && 
+               _data->header.hasType())
+            {
+                _data->header.setType(isTiled(_data->version) ? TILEDIMAGE : SCANLINEIMAGE);
+            }
+            
+            _data->header.sanityCheck (isTiled (_data->version));
+
+            initialize();
+        }
+    }
+    catch (IEX_NAMESPACE::BaseExc &e)
+    {
+        if (is)          delete is;
+         
+        if ( _data && !_data->multiPartBackwardSupport  && _data->_streamData)
+        {
+            delete _data->_streamData;
+            _data->_streamData=NULL;
+        }
+        
+        if (_data)       delete _data;
+        _data=NULL;
+
+        REPLACE_EXC (e, "Cannot read image file "
+			"\"" << fileName << "\". " << e);
+        throw;
+    }
+    catch (...)
+    {
+        if (is)          delete is;
+        if (_data && !_data->multiPartBackwardSupport && _data->_streamData)
+        {
+            delete _data->_streamData;
+        }
+        if (_data)       delete _data;
+
+        throw;
+    }
+}
+
+
+InputFile::InputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads):
+    _data (new Data (numThreads))
+{
+    _data->_streamData=NULL;
+    _data->_deleteStream=false;
+    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);
+            
+            // fix type attribute in single part regular image types
+            // (may be wrong if an old version of OpenEXR converts
+            // a tiled image to scanline or vice versa)
+            if(!isNonImage(_data->version)  && 
+               !isMultiPart(_data->version) &&  
+               _data->header.hasType())
+            {
+                _data->header.setType(isTiled(_data->version) ? TILEDIMAGE : SCANLINEIMAGE);
+            }
+            
+            _data->header.sanityCheck (isTiled (_data->version));
+
+            initialize();
+        }
+    }
+    catch (IEX_NAMESPACE::BaseExc &e)
+    {
+        if (_data && !_data->multiPartBackwardSupport && _data->_streamData) delete _data->_streamData;
+        if (_data)       delete _data;
+        _data=NULL; 
+
+        REPLACE_EXC (e, "Cannot read image file "
+			"\"" << is.fileName() << "\". " << e);
+        throw;
+    }
+    catch (...)
+    {
+        if (_data &&  !_data->multiPartBackwardSupport  && _data->_streamData) delete _data->_streamData;
+        if (_data)       delete _data;
+        _data=NULL;
+        throw;
+    }
+}
+
+
+InputFile::InputFile (InputPartData* part) :
+    _data (new Data (part->numThreads))
+{
+    _data->_deleteStream=false;
+    multiPartInitialize (part);
+}
+
+
+void
+InputFile::compatibilityInitialize (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)
+{
+    is.seekg(0);
+
+    //
+    // Construct a MultiPartInputFile, initialize InputFile
+    // with the part 0 data.
+    // (TODO) may want to have a way to set the reconstruction flag.
+    //
+    _data->multiPartBackwardSupport = true;
+    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);
+    InputPartData* part = _data->multiPartFile->getPart(0);
+
+    multiPartInitialize (part);
+}
+
+
+void
+InputFile::multiPartInitialize (InputPartData* part)
+{
+    _data->_streamData = part->mutex;
+    _data->version = part->version;
+    _data->header = part->header;
+    _data->partNumber = part->partNumber;
+    _data->part = part;
+
+    initialize();
+}
+
+
+void
+InputFile::initialize ()
+{
+    if (!_data->part)
+    {
+        if(_data->header.hasType() && _data->header.type()==DEEPSCANLINE)
+        {
+            _data->isTiled=false;
+            const Box2i &dataWindow = _data->header.dataWindow();
+            _data->minY = dataWindow.min.y;
+            _data->maxY = dataWindow.max.y;
+            
+            _data->dsFile = new DeepScanLineInputFile (_data->header,
+                                               _data->_streamData->is,
+                                               _data->version,
+                                               _data->numThreads);
+            _data->compositor = new CompositeDeepScanLine;
+            _data->compositor->addSource(_data->dsFile);
+        }
+        
+        else if (isTiled (_data->version))
+        {
+            _data->isTiled = true;
+            _data->lineOrder = _data->header.lineOrder();
+
+            //
+            // Save the dataWindow information
+            //
+    
+            const Box2i &dataWindow = _data->header.dataWindow();
+            _data->minY = dataWindow.min.y;
+            _data->maxY = dataWindow.max.y;
+
+            _data->tFile = new TiledInputFile (_data->header,
+                                               _data->_streamData->is,
+                                               _data->version,
+                                               _data->numThreads);
+        }
+        
+        else if(!_data->header.hasType() || _data->header.type()==SCANLINEIMAGE)
+        {
+            _data->sFile = new ScanLineInputFile (_data->header,
+                                                  _data->_streamData->is,
+                                                  _data->numThreads);
+        }else{
+            // type set but not recognised
+            
+            THROW(IEX_NAMESPACE::ArgExc, "InputFile cannot handle parts of type " << _data->header.type());
+        }
+    }
+    else
+    {
+        if(_data->header.hasType() && _data->header.type()==DEEPSCANLINE)
+        {
+            _data->isTiled=false;
+            const Box2i &dataWindow = _data->header.dataWindow();
+            _data->minY = dataWindow.min.y;
+            _data->maxY = dataWindow.max.y;
+            
+            _data->dsFile = new DeepScanLineInputFile (_data->part);
+            _data->compositor = new CompositeDeepScanLine;
+            _data->compositor->addSource(_data->dsFile);
+        }
+        else if (isTiled (_data->header.type()))
+        {
+            _data->isTiled = true;
+            _data->lineOrder = _data->header.lineOrder();
+
+            //
+            // Save the dataWindow information
+            //
+
+            const Box2i &dataWindow = _data->header.dataWindow();
+            _data->minY = dataWindow.min.y;
+            _data->maxY = dataWindow.max.y;
+
+            _data->tFile = new TiledInputFile (_data->part);
+        }
+        else if(!_data->header.hasType() || _data->header.type()==SCANLINEIMAGE)
+        {
+            _data->sFile = new ScanLineInputFile (_data->part);
+        }else{
+            THROW(IEX_NAMESPACE::ArgExc, "InputFile cannot handle parts of type " << _data->header.type());
+            
+        }
+    }
+}
+
+#include <iostream>
+InputFile::~InputFile ()
+{
+    if (_data->_deleteStream)
+        delete _data->_streamData->is;
+
+    // unless this file was opened via the multipart API,
+    // delete the streamData object too
+    if (_data->partNumber==-1 && _data->_streamData)
+        delete _data->_streamData;
+
+    if (_data)  delete _data;
+}
+
+const char *
+InputFile::fileName () const
+{
+    return _data->_streamData->is->fileName();
+}
+
+
+const Header &
+InputFile::header () const
+{
+    return _data->header;
+}
+
+
+int
+InputFile::version () const
+{
+    return _data->version;
+}
+
+
+void
+InputFile::setFrameBuffer (const FrameBuffer &frameBuffer)
+{
+    if (_data->isTiled)
+    {
+	Lock lock (*_data);
+
+	//
+        // We must invalidate the cached buffer if the new frame
+	// buffer has a different set of channels than the old
+	// frame buffer, or if the type of a channel has changed.
+	//
+
+	const FrameBuffer &oldFrameBuffer = _data->tFileBuffer;
+
+	FrameBuffer::ConstIterator i = oldFrameBuffer.begin();
+	FrameBuffer::ConstIterator j = frameBuffer.begin();
+
+	while (i != oldFrameBuffer.end() && j != frameBuffer.end())
+	{
+	    if (strcmp (i.name(), j.name()) || i.slice().type != j.slice().type)
+		break;
+
+	    ++i;
+	    ++j;
+	}
+
+	if (i != oldFrameBuffer.end() || j != frameBuffer.end())
+        {
+	    //
+	    // Invalidate the cached buffer.
+	    //
+
+            _data->deleteCachedBuffer ();
+	    _data->cachedTileY = -1;
+
+	    //
+	    // Create new a cached frame buffer.  It can hold a single
+	    // row of tiles.  The cached buffer can be reused for each
+	    // row of tiles because we set the yTileCoords parameter of
+	    // each Slice to true.
+	    //
+
+	    const Box2i &dataWindow = _data->header.dataWindow();
+	    _data->cachedBuffer = new FrameBuffer();
+	    _data->offset = dataWindow.min.x;
+	    
+	    int tileRowSize = (dataWindow.max.x - dataWindow.min.x + 1) *
+			      _data->tFile->tileYSize();
+
+	    for (FrameBuffer::ConstIterator k = frameBuffer.begin();
+		 k != frameBuffer.end();
+		 ++k)
+	    {
+		Slice s = k.slice();
+
+		switch (s.type)
+		{
+		  case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:
+
+		    _data->cachedBuffer->insert
+			(k.name(),
+			 Slice (UINT,
+				(char *)(new unsigned int[tileRowSize] - 
+					_data->offset),
+				sizeof (unsigned int),
+				sizeof (unsigned int) *
+				    _data->tFile->levelWidth(0),
+				1, 1,
+				s.fillValue,
+				false, true));
+		    break;
+
+		  case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:
+
+		    _data->cachedBuffer->insert
+			(k.name(),
+			 Slice (HALF,
+				(char *)(new half[tileRowSize] - 
+					_data->offset),
+				sizeof (half),
+				sizeof (half) *
+				    _data->tFile->levelWidth(0),
+				1, 1,
+				s.fillValue,
+				false, true));
+		    break;
+
+		  case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:
+
+		    _data->cachedBuffer->insert
+			(k.name(),
+			 Slice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+				(char *)(new float[tileRowSize] - 
+					_data->offset),
+				sizeof(float),
+				sizeof(float) *
+				    _data->tFile->levelWidth(0),
+				1, 1,
+				s.fillValue,
+				false, true));
+		    break;
+
+		  default:
+
+		    throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type.");
+		}
+	    }
+
+	    _data->tFile->setFrameBuffer (*_data->cachedBuffer);
+        }
+
+	_data->tFileBuffer = frameBuffer;
+    }
+    else if(_data->compositor)
+    {
+        _data->compositor->setFrameBuffer(frameBuffer);
+    }else {
+        _data->sFile->setFrameBuffer(frameBuffer);
+        _data->tFileBuffer = frameBuffer;
+    }
+}
+
+
+const FrameBuffer &
+InputFile::frameBuffer () const
+{
+    if(_data->compositor)
+    {
+        return _data->compositor->frameBuffer();
+    }
+    else if(_data->isTiled)
+    {
+	Lock lock (*_data);
+	return _data->tFileBuffer;
+    }
+    else
+    {
+	return _data->sFile->frameBuffer();
+    }
+}
+
+
+bool
+InputFile::isComplete () const
+{
+    if (_data->dsFile)
+        return _data->dsFile->isComplete();
+    else if (_data->isTiled)
+	return _data->tFile->isComplete();
+    else
+	return _data->sFile->isComplete();
+}
+
+bool
+InputFile::isOptimizationEnabled() const
+{
+   if(_data->sFile)
+   {
+       return _data->sFile->isOptimizationEnabled();
+   }else{
+       return false;
+   }
+}
+
+
+void
+InputFile::readPixels (int scanLine1, int scanLine2)
+{
+    if (_data->compositor)
+    {
+        _data->compositor->readPixels(scanLine1,scanLine2);
+    }
+    else if (_data->isTiled)
+    {
+	Lock lock (*_data);
+        bufferedReadPixels (_data, scanLine1, scanLine2);
+    }
+    else
+    {
+        _data->sFile->readPixels (scanLine1, scanLine2);
+    }
+}
+
+
+void
+InputFile::readPixels (int scanLine)
+{
+    readPixels (scanLine, scanLine);
+}
+
+
+void
+InputFile::rawPixelData (int firstScanLine,
+			 const char *&pixelData,
+			 int &pixelDataSize)
+{
+    try
+    {
+        if (_data->dsFile)
+        {
+            throw IEX_NAMESPACE::ArgExc ("Tried to read a raw scanline "
+            "from a deep image.");
+        }
+        
+	else if (_data->isTiled)
+	{
+	    throw IEX_NAMESPACE::ArgExc ("Tried to read a raw scanline "
+			       "from a tiled image.");
+	}
+        
+        _data->sFile->rawPixelData (firstScanLine, pixelData, pixelDataSize);
+    }
+    catch (IEX_NAMESPACE::BaseExc &e)
+    {
+	REPLACE_EXC (e, "Error reading pixel data from image "
+		        "file \"" << fileName() << "\". " << e);
+	throw;
+    }
+}
+
+
+void
+InputFile::rawTileData (int &dx, int &dy,
+			int &lx, int &ly,
+			const char *&pixelData,
+			int &pixelDataSize)
+{
+    try
+    {
+	if (!_data->isTiled)
+	{
+	    throw IEX_NAMESPACE::ArgExc ("Tried to read a raw tile "
+			       "from a scanline-based image.");
+	}
+        
+        _data->tFile->rawTileData (dx, dy, lx, ly, pixelData, pixelDataSize);
+    }
+    catch (IEX_NAMESPACE::BaseExc &e)
+    {
+	REPLACE_EXC (e, "Error reading tile data from image "
+		        "file \"" << fileName() << "\". " << e);
+	throw;
+    }
+}
+
+
+TiledInputFile*
+InputFile::tFile()
+{
+    if (!_data->isTiled)
+    {
+	throw IEX_NAMESPACE::ArgExc ("Cannot get a TiledInputFile pointer "
+			   "from an InputFile that is not tiled.");
+    }
+
+    return _data->tFile;
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT