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

//

// 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 ScanLineInputFile

//

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

#include "ImfScanLineInputFile.h"

#include "ImfChannelList.h"

#include "ImfMisc.h"

#include "ImfStdIO.h"

#include "ImfCompressor.h"

#include "ImathBox.h"

#include "ImathFun.h"

#include <ImfXdr.h>

#include <ImfConvert.h>

#include <ImfThreading.h>

#include <ImfPartType.h>

#include "IlmThreadPool.h"

#include "IlmThreadSemaphore.h"

#include "IlmThreadMutex.h"

#include "Iex.h"

#include "ImfVersion.h"

#include "ImfOptimizedPixelReading.h"

#include "ImfNamespace.h"

#include "ImfStandardAttributes.h"

#include <algorithm>

#include <string>

#include <vector>

#include <assert.h>

#include <cstring>

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::divp;

using IMATH_NAMESPACE::modp;

using std::string;

using std::vector;

using std::ifstream;

using std::min;

using std::max;

using std::sort;

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 InSliceInfo

{

    PixelType	typeInFrameBuffer;

    PixelType	typeInFile;

    char *	base;

    size_t	xStride;

    size_t	yStride;

    int		xSampling;

    int		ySampling;

    bool	fill;

    bool	skip;

    double	fillValue;

    InSliceInfo (PixelType typeInFrameBuffer = HALF,

		 PixelType typeInFile = HALF,

	         char *base = 0,

	         size_t xStride = 0,

	         size_t yStride = 0,

	         int xSampling = 1,

	         int ySampling = 1,

	         bool fill = false,

	         bool skip = false,

	         double fillValue = 0.0);

};

InSliceInfo::InSliceInfo (PixelType tifb,

			  PixelType tifl,

			  char *b,

			  size_t xs, size_t ys,

			  int xsm, int ysm,

			  bool f, bool s,

			  double fv)

:

    typeInFrameBuffer (tifb),

    typeInFile (tifl),

    base (b),

    xStride (xs),

    yStride (ys),

    xSampling (xsm),

    ySampling (ysm),

    fill (f),

    skip (s),

    fillValue (fv)

{

    // empty

}

struct LineBuffer

{

    const char *	uncompressedData;

    char *		buffer;

    int			dataSize;

    int			minY;

    int			maxY;

    Compressor *	compressor;

    Compressor::Format	format;

    int			number;

    bool		hasException;

    string		exception;

    LineBuffer (Compressor * const comp);

    ~LineBuffer ();

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

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

  private:

    Semaphore		_sem;

};

LineBuffer::LineBuffer (Compressor *comp):

    uncompressedData (0),

    buffer (0),

    dataSize (0),

    compressor (comp),

    format (defaultFormat(compressor)),

    number (-1),

    hasException (false),

    exception (),

    _sem (1)

{

    // empty

}

LineBuffer::~LineBuffer ()

{

    delete compressor;

}

/// helper struct used to detect the order that the channels are stored

struct sliceOptimizationData

{

    const char * base;   ///< pointer to pixel data 

    bool fill;           ///< is this channel being filled with constant, instead of read?

    half fillValue;      ///< if filling, the value to use

    size_t offset;       ///< position this channel will be in the read buffer, accounting for previous channels, as well as their type

    PixelType type;      ///< type of channel

    size_t xStride;      ///< x-stride of channel in buffer (must be set to cause channels to interleave)

    size_t yStride;      ///< y-stride of channel in buffer (must be same in all channels, else order will change, which is bad)

    int xSampling;       ///< channel x sampling

    int ySampling;       ///< channel y sampling

    /// we need to keep the list sorted in the order they'll be written to memory

    bool operator<(const sliceOptimizationData& other ) const

    {

        return base < other.base;

    }

};

} // namespace

struct ScanLineInputFile::Data: public Mutex

{

    Header		header;		    // the image header

    int			version;            // file's version

    FrameBuffer		frameBuffer;	    // framebuffer to write into

    LineOrder		lineOrder;          // order of the scanlines in file

    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

    vector<Int64>	lineOffsets;	    // stores offsets in file for

					    // each line

    bool		fileIsComplete;	    // True if no scanlines are missing

    					    // in the file

    int			nextLineBufferMinY; // minimum y of the next linebuffer

    vector<size_t>	bytesPerLine;       // combined size of a line over all

                                            // channels

    vector<size_t>	offsetInLineBuffer; // offset for each scanline in its

                                            // linebuffer

    vector<InSliceInfo>	slices;             // info about channels in file

    vector<LineBuffer*> lineBuffers;        // each holds one line buffer

    int			linesInBuffer;      // number of scanlines each buffer

                                            // holds

    size_t		lineBufferSize;     // size of the line buffer

    int                 partNumber;         // part number

    bool                memoryMapped;       // if the stream is memory mapped

    OptimizationMode    optimizationMode;   // optimizibility of the input file

    vector<sliceOptimizationData>  optimizationData; ///< channel ordering for optimized reading

    Data (int numThreads);

    ~Data ();

    inline LineBuffer * getLineBuffer (int number); // hash function from line

    						    // buffer indices into our

						    // vector of line buffers

};

ScanLineInputFile::Data::Data (int numThreads):

        partNumber(-1),

        memoryMapped(false)

{

    //

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

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

    //

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

}

ScanLineInputFile::Data::~Data ()

{

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

        delete lineBuffers[i];

}

inline LineBuffer *

ScanLineInputFile::Data::getLineBuffer (int lineBufferNumber)

{

    return lineBuffers[lineBufferNumber % lineBuffers.size()];

}

namespace {

void

reconstructLineOffsets (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,

			LineOrder lineOrder,

			vector<Int64> &lineOffsets)

{

    Int64 position = is.tellg();

    try

    {

	for (unsigned int i = 0; i < lineOffsets.size(); i++)

	{

	    Int64 lineOffset = is.tellg();

	    int y;

	    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, y);

	    int dataSize;

	    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, dataSize);

	    Xdr::skip <StreamIO> (is, dataSize);

	    if (lineOrder == INCREASING_Y)

		lineOffsets[i] = lineOffset;

	    else

		lineOffsets[lineOffsets.size() - i - 1] = lineOffset;

	}

    }

    catch (...)

    {

	//

	// Suppress all exceptions.  This functions is

	// called only to reconstruct the line offset

	// table for incomplete files, and exceptions

	// are likely.

	//

    }

    is.clear();

    is.seekg (position);

}

void

readLineOffsets (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,

		 LineOrder lineOrder,

		 vector<Int64> &lineOffsets,

		 bool &complete)

{

    for (unsigned int i = 0; i < lineOffsets.size(); i++)

    {

	OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, lineOffsets[i]);

    }

    complete = true;

    for (unsigned int i = 0; i < lineOffsets.size(); i++)

    {

	if (lineOffsets[i] <= 0)

	{

	    //

	    // Invalid data in the line offset table mean that

	    // the file is probably incomplete (the table is

	    // the last thing written to the file).  Either

	    // some process is still busy writing the file,

	    // or writing the file was aborted.

	    //

	    // We should still be able to read the existing

	    // parts of the file.  In order to do this, we

	    // have to make a sequential scan over the scan

	    // line data to reconstruct the line offset table.

	    //

	    complete = false;

	    reconstructLineOffsets (is, lineOrder, lineOffsets);

	    break;

	}

    }

}

void

readPixelData (InputStreamMutex *streamData,

               ScanLineInputFile::Data *ifd,

	       int minY,

	       char *&buffer,

	       int &dataSize)

{

    //

    // Read a single line buffer from the input file.

    //

    // If the input file is not memory-mapped, we copy the pixel data into

    // into the array pointed to by buffer.  If the file is memory-mapped,

    // then we change where buffer points to instead of writing into the

    // array (hence buffer needs to be a reference to a char *).

    //

    int lineBufferNumber = (minY - ifd->minY) / ifd->linesInBuffer;

    Int64 lineOffset = ifd->lineOffsets[lineBufferNumber];

    if (lineOffset == 0)

	THROW (IEX_NAMESPACE::InputExc, "Scan line " << minY << " is missing.");

    //

    // Seek to the start of the scan line in the file,

    // if necessary.

    //

    if ( !isMultiPart(ifd->version) )

    {

        if (ifd->nextLineBufferMinY != minY)

            streamData->is->seekg (lineOffset);

    }

    else

    {

        //

        // In a multi-part file, the file pointer may have been moved by

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

        //

        if (streamData->is->tellg() != ifd->lineOffsets[lineBufferNumber])

            streamData->is->seekg (lineOffset);

    }

    //

    // Read the data block's header.

    //

    int yInFile;

    //

    // Read the part number when we are dealing with a multi-part file.

    //

    if (isMultiPart(ifd->version))

    {

        int partNumber;

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

        if (partNumber != ifd->partNumber)

        {

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

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

        }

    }

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

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

    if (yInFile != minY)

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

    if (dataSize > (int) ifd->lineBufferSize)

	throw IEX_NAMESPACE::InputExc ("Unexpected data block length.");

    //

    // Read the pixel data.

    //

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

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

    else

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

    //

    // Keep track of which scan line is the next one in

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

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

    //

    if (ifd->lineOrder == INCREASING_Y)

        ifd->nextLineBufferMinY = minY + ifd->linesInBuffer;

    else

        ifd->nextLineBufferMinY = minY - ifd->linesInBuffer;

}

//

// A LineBufferTask encapsulates the task uncompressing a set of

// scanlines (line buffer) and copying them into the frame buffer.

//

class LineBufferTask : public Task

{

  public:

    LineBufferTask (TaskGroup *group,

                    ScanLineInputFile::Data *ifd,

		    LineBuffer *lineBuffer,

                    int scanLineMin,

		    int scanLineMax,

                    OptimizationMode optimizationMode);

    virtual ~LineBufferTask ();

    virtual void		execute ();

  private:

    ScanLineInputFile::Data *	_ifd;

    LineBuffer *		_lineBuffer;

    int				_scanLineMin;

    int				_scanLineMax;

    OptimizationMode            _optimizationMode;

};

LineBufferTask::LineBufferTask

    (TaskGroup *group,

     ScanLineInputFile::Data *ifd,

     LineBuffer *lineBuffer,

     int scanLineMin,

     int scanLineMax,OptimizationMode optimizationMode)

:

    Task (group),

    _ifd (ifd),

    _lineBuffer (lineBuffer),

    _scanLineMin (scanLineMin),

    _scanLineMax (scanLineMax),

    _optimizationMode(optimizationMode)

{

    // empty

}

LineBufferTask::~LineBufferTask ()

{

    //

    // Signal that the line buffer is now free

    //

    _lineBuffer->post ();

}

void

LineBufferTask::execute ()

{

    try

    {

        //

        // Uncompress the data, if necessary

        //

        if (_lineBuffer->uncompressedData == 0)

        {

            int uncompressedSize = 0;

            int maxY = min (_lineBuffer->maxY, _ifd->maxY);

            for (int i = _lineBuffer->minY - _ifd->minY;

                 i <= maxY - _ifd->minY;

		 ++i)

	    {

                uncompressedSize += (int) _ifd->bytesPerLine[i];

	    }

            if (_lineBuffer->compressor &&

                _lineBuffer->dataSize < uncompressedSize)

            {

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

                _lineBuffer->dataSize = _lineBuffer->compressor->uncompress

                    (_lineBuffer->buffer,

                     _lineBuffer->dataSize,

		     _lineBuffer->minY,

                     _lineBuffer->uncompressedData);

            }

            else

            {

                //

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

                // regardless of the compressor's output format.

                //

                _lineBuffer->format = Compressor::XDR;

                _lineBuffer->uncompressedData = _lineBuffer->buffer;

            }

        }

        int yStart, yStop, dy;

        if (_ifd->lineOrder == INCREASING_Y)

        {

            yStart = _scanLineMin;

            yStop = _scanLineMax + 1;

            dy = 1;

        }

        else

        {

            yStart = _scanLineMax;

            yStop = _scanLineMin - 1;

            dy = -1;

        }

        for (int y = yStart; y != yStop; y += dy)

        {

            //

            // Convert one scan line's worth of pixel data back

            // from the machine-independent representation, and

            // store the result in the frame buffer.

            //

            const char *readPtr = _lineBuffer->uncompressedData +

                                  _ifd->offsetInLineBuffer[y - _ifd->minY];

            //

            // Iterate over all image channels.

            //

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

            {

                //

                // Test if scan line y of this channel contains any data

		// (the scan line contains data only if y % ySampling == 0).

                //

                const InSliceInfo &slice = _ifd->slices[i];

                if (modp (y, slice.ySampling) != 0)

                    continue;

                //

                // Find the x coordinates of the leftmost and rightmost

                // sampled pixels (i.e. pixels within the data window

                // for which x % xSampling == 0).

                //

                int dMinX = divp (_ifd->minX, slice.xSampling);

                int dMaxX = divp (_ifd->maxX, slice.xSampling);

                //

		// 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, dMaxX - dMinX + 1);

                }

                else

                {

                    //

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

                    //

                    char *linePtr  = slice.base +

                                        divp (y, slice.ySampling) *

                                        slice.yStride;

                    char *writePtr = linePtr + dMinX * slice.xStride;

                    char *endPtr   = linePtr + dMaxX * slice.xStride;

                    copyIntoFrameBuffer (readPtr, writePtr, endPtr,

                                         slice.xStride, slice.fill,

                                         slice.fillValue, _lineBuffer->format,

                                         slice.typeInFrameBuffer,

                                         slice.typeInFile);

                }

            }

        }

    }

    catch (std::exception &e)

    {

        if (!_lineBuffer->hasException)

        {

            _lineBuffer->exception = e.what();

            _lineBuffer->hasException = true;

        }

    }

    catch (...)

    {

        if (!_lineBuffer->hasException)

        {

            _lineBuffer->exception = "unrecognized exception";

            _lineBuffer->hasException = true;

        }

    }

}

#ifdef IMF_HAVE_SSE2

//

// IIF format is more restricted than a perfectly generic one,

// so it is possible to perform some optimizations.

//

class LineBufferTaskIIF : public Task

{

    public:

        LineBufferTaskIIF (TaskGroup *group,

                           ScanLineInputFile::Data *ifd,

                           LineBuffer *lineBuffer,

                           int scanLineMin,

                           int scanLineMax,

                           OptimizationMode optimizationMode);

        virtual ~LineBufferTaskIIF ();

        virtual void                execute ();

        template<typename TYPE>

        void getWritePointer (int y,

                              unsigned short*& pOutWritePointerRight,

                              size_t& outPixelsToCopySSE,

                              size_t& outPixelsToCopyNormal,int bank=0) const;

        template<typename TYPE>

        void getWritePointerStereo (int y,

                                    unsigned short*& outWritePointerRight,

                                    unsigned short*& outWritePointerLeft,

                                    size_t& outPixelsToCopySSE,

                                    size_t& outPixelsToCopyNormal) const;

    private:

        ScanLineInputFile::Data *   _ifd;

        LineBuffer *                _lineBuffer;

        int                         _scanLineMin;

        int                         _scanLineMax;

        OptimizationMode            _optimizationMode;

};

LineBufferTaskIIF::LineBufferTaskIIF

    (TaskGroup *group,

     ScanLineInputFile::Data *ifd,

     LineBuffer *lineBuffer,

     int scanLineMin,

     int scanLineMax,

     OptimizationMode optimizationMode

    )

    :

     Task (group),

     _ifd (ifd),

     _lineBuffer (lineBuffer),

     _scanLineMin (scanLineMin),

     _scanLineMax (scanLineMax),

     _optimizationMode (optimizationMode)

{

     /*

     //

     // indicates the optimised path has been taken

     //

     static bool could_optimise=false;

     if(could_optimise==false)

     {

         std::cerr << " optimised path\n";

         could_optimise=true;

     }

     */

}

LineBufferTaskIIF::~LineBufferTaskIIF ()

{

     //

     // Signal that the line buffer is now free

     //

     _lineBuffer->post ();

}

// Return 0 if we are to skip because of sampling

// channelBank is 0 for the first group of channels, 1 for the second

template<typename TYPE>

void LineBufferTaskIIF::getWritePointer 

                            (int y,

                             unsigned short*& outWritePointerRight,

                             size_t& outPixelsToCopySSE,

                             size_t& outPixelsToCopyNormal,

                             int channelBank

                            ) const

{

      // Channels are saved alphabetically, so the order is B G R.

      // The last slice (R) will give us the location of our write pointer.

      // The only slice that we support skipping is alpha, i.e. the first one.  

      // This does not impact the write pointer or the pixels to copy at all.

      size_t nbSlicesInBank = _ifd->optimizationData.size();

      int sizeOfSingleValue = sizeof(TYPE);

      if(_ifd->optimizationData.size()>4)

      {

          // there are two banks - we only copy one at once

          nbSlicesInBank/=2;

      }

      size_t firstChannel = 0;

      if(channelBank==1)

      {

          firstChannel = _ifd->optimizationData.size()/2;

      }

       sliceOptimizationData& firstSlice = _ifd->optimizationData[firstChannel];

      if (modp (y, firstSlice.ySampling) != 0)

      {

          outPixelsToCopySSE    = 0;

          outPixelsToCopyNormal = 0;

          outWritePointerRight  = 0;

      }

      const char* linePtr1  = firstSlice.base +

      divp (y, firstSlice.ySampling) *

      firstSlice.yStride;

      int dMinX1 = divp (_ifd->minX, firstSlice.xSampling);

      int dMaxX1 = divp (_ifd->maxX, firstSlice.xSampling);

      // Construct the writePtr so that we start writing at

      // linePtr + Min offset in the line.

      outWritePointerRight =  (unsigned short*)(linePtr1 +

      dMinX1 * firstSlice.xStride );

      size_t bytesToCopy  = ((linePtr1 + dMaxX1 * firstSlice.xStride ) -

      (linePtr1 + dMinX1 * firstSlice.xStride )) + 2;

      size_t shortsToCopy = bytesToCopy / sizeOfSingleValue;

      size_t pixelsToCopy = (shortsToCopy / nbSlicesInBank ) + 1;

      // We only support writing to SSE if we have no pixels to copy normally

      outPixelsToCopySSE    = pixelsToCopy / 8;

      outPixelsToCopyNormal = pixelsToCopy % 8;

}

template<typename TYPE>

void LineBufferTaskIIF::getWritePointerStereo 

                          (int y,

                           unsigned short*& outWritePointerRight,

                           unsigned short*& outWritePointerLeft,

                           size_t& outPixelsToCopySSE,

                           size_t& outPixelsToCopyNormal) const

{

   getWritePointer<TYPE>(y,outWritePointerRight,outPixelsToCopySSE,outPixelsToCopyNormal,0);

   if(outWritePointerRight)

   {

       getWritePointer<TYPE>(y,outWritePointerLeft,outPixelsToCopySSE,outPixelsToCopyNormal,1);

   }

}

void

LineBufferTaskIIF::execute()

{

    try

    {

        //

        // Uncompress the data, if necessary

        //

        if (_lineBuffer->uncompressedData == 0)

        {

            int uncompressedSize = 0;

            int maxY = min (_lineBuffer->maxY, _ifd->maxY);

            for (int i = _lineBuffer->minY - _ifd->minY;

            i <= maxY - _ifd->minY;

            ++i)

            {

                uncompressedSize += (int) _ifd->bytesPerLine[i];

            }

            if (_lineBuffer->compressor &&

                _lineBuffer->dataSize < uncompressedSize)

            {

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

                _lineBuffer->dataSize =

                _lineBuffer->compressor->uncompress (_lineBuffer->buffer,

                                                     _lineBuffer->dataSize,

                                                     _lineBuffer->minY,

                                                     _lineBuffer->uncompressedData);

            }

            else

            {

                //

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

                // regardless of the compressor's output format.

                //

                _lineBuffer->format = Compressor::XDR;

                _lineBuffer->uncompressedData = _lineBuffer->buffer;

            }

        }

        int yStart, yStop, dy;

        if (_ifd->lineOrder == INCREASING_Y)

        {

            yStart = _scanLineMin;

            yStop = _scanLineMax + 1;

            dy = 1;

        }

        else