/*****************************************************************************/
// SGITranslator
// Written by Stephan Aßmus <stippi@yellowbites.com>
// derived from GIMP SGI plugin by Michael Sweet
//
// SGIImage.cpp
//
// SGI image file format library routines.
//
// Formed into a class SGIImage, adopted to Be API and modified to use
// BPositionIO, optimizations for buffered reading.
//
//
// Copyright (c) 2003 Haiku Project
// Portions Copyright 1997-1998 Michael Sweet (mike@easysw.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the 
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included 
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/

#include <malloc.h>
#include <stdio.h>
#include <string.h>

#include <ByteOrder.h>
#include <DataIO.h>
#include <TranslationErrors.h>

#include "SGIImage.h"

const char kSGICopyright[] = "" B_UTF8_COPYRIGHT " 1997-1998 Michael Sweet "
        "<mike@easysw.com>";

// constructor
SGIImage::SGIImage()
        : fStream(NULL),
          fMode(0),
          fBytesPerChannel(0),
          fCompression(0),
          fWidth(0),
          fHeight(0),
          fChannelCount(0),
          fFirstRowOffset(0),
          fNextRowOffset(0),
          fOffsetTable(NULL),
          fLengthTable(NULL),
          fARLERow(NULL),
          fARLEOffset(0),
          fARLELength(0)
{
}

// destructor
SGIImage::~SGIImage()
{
        Unset();
}

// InitCheck
status_t
SGIImage::InitCheck() const
{
        if (fStream)
                return B_OK;
        return B_NO_INIT;
}

// SetTo
// open an SGI image file for reading
//
// stream       the input stream
status_t
SGIImage::SetTo(BPositionIO* stream)
{
        if (!stream)
                return B_BAD_VALUE;

        fStream = stream;
        stream->Seek(0, SEEK_SET);

        int16 magic = _ReadShort();
        if (magic != SGI_MAGIC) {
                fStream = NULL;
                return B_NO_TRANSLATOR;
        }

        fMode = SGI_READ;

        fCompression = _ReadChar();
        fBytesPerChannel = _ReadChar();
        _ReadShort();   // Dimensions
        fWidth = _ReadShort();
        fHeight = _ReadShort();
        fChannelCount = _ReadShort();
//      _ReadLong();    // Minimum pixel
//      _ReadLong();    // Maximum pixel

        if (fCompression) {
                // this stream is compressed; read the scanline tables...

                fStream->Seek(512, SEEK_SET);

                fOffsetTable    = (int32**)calloc(fChannelCount, sizeof(int32*));
                fOffsetTable[0] = (int32*)calloc(fHeight * fChannelCount, sizeof(int32));
                for (uint32 i = 1; i < fChannelCount; i++)
                        fOffsetTable[i] = fOffsetTable[0] + i * fHeight;

                for (uint32 i = 0; i < fChannelCount; i++)
                        for (uint16 j = 0; j < fHeight; j++)
                                fOffsetTable[i][j] = _ReadLong();

                fLengthTable    = (int32**)calloc(fChannelCount, sizeof(int32*));
                fLengthTable[0] = (int32*)calloc(fHeight * fChannelCount, sizeof(int32));

                for (int32 i = 1; i < fChannelCount; i ++)
                        fLengthTable[i] = fLengthTable[0] + i * fHeight;

                for (uint32 i = 0; i < fChannelCount; i++)
                        for (uint16 j = 0; j < fHeight; j++)
                                fLengthTable[i][j] = _ReadLong();

        }
        return B_OK;
}

// SetTo
// open an SGI image file for writing
//
// stream                       the output stream
// width                        number of pixels in a row
// height                       number of rows
// channels                     number of channels per pixel
// bytesPerChannel      number of bytes per channel
// compression          compression mode
status_t
SGIImage::SetTo(BPositionIO* stream,
                                uint16 width, uint16 height,
                                uint16 channels, uint32 bytesPerChannel,
                                uint32 compression)
{
        // sanity checks
        if (!stream ||
                width < 1 || height < 1 || channels < 1 ||
                bytesPerChannel < 1 || bytesPerChannel > 2 ||
                compression < SGI_COMP_NONE || compression > SGI_COMP_ARLE)
                return B_BAD_VALUE;

        fStream = stream;
        fMode = SGI_WRITE;

        _WriteShort(SGI_MAGIC);
        _WriteChar((fCompression = compression) != 0);
        _WriteChar(fBytesPerChannel = bytesPerChannel);
        _WriteShort(3);         // Dimensions
        _WriteShort(fWidth = width);
        _WriteShort(fHeight = height);
        _WriteShort(fChannelCount = channels);

        if (fBytesPerChannel == 1) {
                _WriteLong(0);          // Minimum pixel
                _WriteLong(255);        // Maximum pixel
        } else {
                _WriteLong(-32768);     // Minimum pixel
                _WriteLong(32767);      // Maximum pixel
        }
        _WriteLong(0);                  // Reserved

        char name[80];  // Name of file in image header
        memset(name, 0, sizeof(name));
        sprintf(name, "Haiku SGITranslator");
        fStream->Write(name, sizeof(name));

        // fill the rest of the image header with zeros
        for (int32 i = 0; i < 102; i++)
                _WriteLong(0);

        switch (fCompression) {
                case SGI_COMP_NONE : // No compression
                        // This file is uncompressed.  To avoid problems with
                        // sparse files, we need to write blank pixels for the
                        // entire image...

/*                      if (fBytesPerChannel == 1) {
                                for (int32 i = fWidth * fHeight * fChannelCount; i > 0; i --)
                                        _WriteChar(0);
                        } else {
                                for (int32 i = fWidth * fHeight * fChannelCount; i > 0; i --)
                                        _WriteShort(0);
                        }*/
                        break;

                case SGI_COMP_ARLE: // Aggressive RLE
                        fARLERow        = (uint16*)calloc(fWidth, sizeof(uint16));
                        fARLEOffset = 0;
                        // FALL THROUGH
                case SGI_COMP_RLE : // Run-Length Encoding
                        // This file is compressed; write the (blank) scanline tables...

//                      for (int32 i = 2 * fHeight * fChannelCount; i > 0; i--)
//                              _WriteLong(0);
fStream->Seek(2 * fHeight * fChannelCount * sizeof(int32), SEEK_CUR);

                        fFirstRowOffset = fStream->Position();
                        fNextRowOffset  = fStream->Position();

                        // allocate and read offset table
                        fOffsetTable    = (int32**)calloc(fChannelCount, sizeof(int32*));
                        fOffsetTable[0] = (int32*)calloc(fHeight * fChannelCount, sizeof(int32));

                        for (int32 i = 1; i < fChannelCount; i ++)
                                fOffsetTable[i] = fOffsetTable[0] + i * fHeight;

                        // allocate and read length table
                        fLengthTable    = (int32**)calloc(fChannelCount, sizeof(int32*));
                        fLengthTable[0] = (int32*)calloc(fHeight * fChannelCount, sizeof(int32));

                        for (int32 i = 1; i < fChannelCount; i ++)
                                fLengthTable[i] = fLengthTable[0] + i * fHeight;
                        break;
        }
        return B_OK;
}

// Unset
//
// if in write mode, writes final information to the stream
status_t
SGIImage::Unset()
{
        status_t ret = InitCheck(); // return status
        if (ret >= B_OK) {

                if (fMode == SGI_WRITE && fCompression != SGI_COMP_NONE) {
                        // write the scanline offset table to the file...
                
                        fStream->Seek(512, SEEK_SET);

/*                      off_t* offset = fOffsetTable[0];
                        for (int32 i = fHeight * fChannelCount; i > 0; i--) {
                                if ((ret = _WriteLong(offset[0])) < B_OK)
                                        break;
                                offset++;
                        }*/

int32 size = fHeight * fChannelCount * sizeof(int32);
swap_data(B_INT32_TYPE, fOffsetTable[0], size, B_SWAP_HOST_TO_BENDIAN);
ret = fStream->Write(fOffsetTable[0], size);

                        if (ret >= B_OK) {

/*                              int32* length = fLengthTable[0];
                                for (int32 i = fHeight * fChannelCount; i > 0; i--) {
                                        if ((ret = _WriteLong(length[0])) < B_OK)
                                                break;
                                        length++;
                                }*/

swap_data(B_INT32_TYPE, fLengthTable[0], size, B_SWAP_HOST_TO_BENDIAN);
ret = fStream->Write(fLengthTable[0], size);

                        }
                }
                
                if (fOffsetTable != NULL) {
                        free(fOffsetTable[0]);
                        free(fOffsetTable);
                        fOffsetTable = NULL;
                }
                
                if (fLengthTable != NULL) {
                        free(fLengthTable[0]);
                        free(fLengthTable);
                        fLengthTable = NULL;
                }
                
                if (fARLERow) {
                        free(fARLERow);
                        fARLERow = NULL;
                }

                fStream = NULL;
        }
        return ret;
}

// ReadRow
//
// reads a row of image data from the stream
//
// row                  pointer to buffer (row of pixels) to read
// y                    index (line number) of this row
// z                    which channel to read
status_t
SGIImage::ReadRow(void* row, int32 y, int32 z)
{
        // sanitiy checks
        if (row == NULL ||
                y < 0 || y >= fHeight ||
                z < 0 || z >= fChannelCount)
                return B_BAD_VALUE;


        status_t ret = B_ERROR;

        switch (fCompression) {
                case SGI_COMP_NONE: {
                        // seek to the image row
                        // optimize buffering by only seeking if necessary...

                        off_t offset = 512 + (y + z * fHeight) * fWidth * fBytesPerChannel;
                        fStream->Seek(offset, SEEK_SET);

                        uint32 bytes = fWidth * fBytesPerChannel;
//printf("reading %ld bytes 8 Bit uncompressed row: %ld, channel: %ld\n", bytes, y, z);
                        ret = fStream->Read(row, bytes);

                        break;
                }
                case SGI_COMP_RLE: {
                        int32 offset = fOffsetTable[z][y];
                        int32 rleLength = fLengthTable[z][y];
                        fStream->Seek(offset, SEEK_SET);
                        uint8* rleBuffer = new uint8[rleLength];
                        fStream->Read(rleBuffer, rleLength);

                        if (fBytesPerChannel == 1) {
//printf("reading 8 Bit RLE compressed row: %ld, channel: %ld\n", y, z);
//                              ret = _ReadRLE8((uint8*)row, fWidth);
                                ret = _ReadRLE8((uint8*)row, rleBuffer, fWidth);
                        } else {
//printf("reading 16 Bit RLE compressed row: %ld, channel: %ld\n", y, z);
//                              ret = _ReadRLE16((uint16*)row, fWidth);
                                if ((ret = swap_data(B_INT16_TYPE, rleBuffer, rleLength, B_SWAP_BENDIAN_TO_HOST)) >= B_OK)
                                        ret = _ReadRLE16((uint16*)row, (uint16*)rleBuffer, fWidth);
                        }
                        delete[] rleBuffer;
                        break;
                }
        }
        return ret;
}

// WriteRow
//
// writes a row of image data to the stream
//
// row                  pointer to buffer (row of pixels) to write
// y                    index (line number) of this row
// z                    which channel to write
status_t
SGIImage::WriteRow(void* row, int32 y, int32 z)
{
        // sanitiy checks
        if (row == NULL ||
                y < 0 || y >= fHeight ||
                z < 0 || z >= fChannelCount)
                return B_BAD_VALUE;

        int32 x;                // x coordinate
        int32 offset;   // stream offset

        status_t ret = B_ERROR;

        switch (fCompression) {
                case SGI_COMP_NONE: {
                        // Seek to the image row

                        offset = 512 + (y + z * fHeight) * fWidth * fBytesPerChannel;
                        fStream->Seek(offset, SEEK_SET);

                        uint32 bytes = fWidth * fBytesPerChannel;
//printf("writing %ld bytes %ld byte/channel uncompressed row: %ld, channel: %ld\n", bytes, fBytesPerChannel, y, z);
                        ret = fStream->Write(row, bytes);
/*                      if (fBytesPerChannel == 1) {
                                for (x = fWidth; x > 0; x--) {
                                        _WriteChar(*row);
                                        row++;
                                }
                        } else {
                                for (x = fWidth; x > 0; x--) {
                                        _WriteShort(*row);
                                        row++;
                                }
                        }*/
                        break;
                }
                case SGI_COMP_ARLE:
                        if (fOffsetTable[z][y] != 0)
                                return B_ERROR;

                        // First check the last row written...

                        if (fARLEOffset > 0) {
                                if (fBytesPerChannel == 1) {
                                        uint8* arleRow = (uint8*)fARLERow;
                                        uint8* src = (uint8*)row;
                                        for (x = 0; x < fWidth; x++)
                                                if (*src++ != *arleRow++)
                                                        break;
                                } else {
                                        uint16* arleRow = (uint16*)fARLERow;
                                        uint16* src = (uint16*)row;
                                        for (x = 0; x < fWidth; x++)
                                                if (*src++ != *arleRow++)
                                                        break;
                                }

                                if (x == fWidth) {
                                        fOffsetTable[z][y] = fARLEOffset;
                                        fLengthTable[z][y] = fARLELength;
                                        return B_OK;
                                }
                        }

                        // If that didn't match, search all the previous rows...

                        fStream->Seek(fFirstRowOffset, SEEK_SET);

                        if (fBytesPerChannel == 1) {
                                do {
                                        fARLEOffset = fStream->Position();

                                        uint8* arleRow = (uint8*)fARLERow;
                                        if ((fARLELength = _ReadRLE8(arleRow, fWidth)) < B_OK) {
                                                x = 0;
                                                break;
                                        }

                                        uint8* src = (uint8*)row;
                                        for (x = 0; x < fWidth; x++)
                                                if (*src++ != *arleRow++)
                                                        break;
                                } while (x < fWidth);
                        } else {
                                do {
                                        fARLEOffset = fStream->Position();

                                        uint16* arleRow = (uint16*)fARLERow;
                                        if ((fARLELength = _ReadRLE16(arleRow, fWidth)) < B_OK) {
                                                x = 0;
                                                break;
                                        }

                                        uint16* src = (uint16*)row;
                                        for (x = 0; x < fWidth; x++)
                                                if (*src++ != *arleRow++)
                                                        break;
                                } while (x < fWidth);
                        }

                        if (x == fWidth) {
                                fOffsetTable[z][y] = fARLEOffset;
                                fLengthTable[z][y] = fARLELength;
                                return B_OK;
                        } else
                                fStream->Seek(0, SEEK_END);     // seek to end of stream
                        // FALL THROUGH!
                case SGI_COMP_RLE :
                        if (fOffsetTable[z][y] != 0)
                                return B_ERROR;

                        offset = fOffsetTable[z][y] = fNextRowOffset;

                        if (offset != fStream->Position())
                                fStream->Seek(offset, SEEK_SET);

//printf("writing %d pixels %ld byte/channel RLE row: %ld, channel: %ld\n", fWidth, fBytesPerChannel, y, z);

                        if (fBytesPerChannel == 1)
                                x = _WriteRLE8((uint8*)row, fWidth);
                        else
                                x = _WriteRLE16((uint16*)row, fWidth);

                        if (fCompression == SGI_COMP_ARLE) {
                                fARLEOffset = offset;
                                fARLELength = x;
                                memcpy(fARLERow, row, fWidth * fBytesPerChannel);
                        }

                        fNextRowOffset = fStream->Position();
                        fLengthTable[z][y] = x;

                        return x;
                default:
                        break;
        }

        return ret;
}

// _ReadLong
//
// reads 4 bytes from the stream and
// returns a 32-bit big-endian integer
int32
SGIImage::_ReadLong() const
{
        int32 n;
        if (fStream->Read(&n, 4) == 4) {
                return B_BENDIAN_TO_HOST_INT32(n);
        } else
                return 0;
}

// _ReadShort
//
// reads 2 bytes from the stream and
// returns a 16-bit big-endian integer
int16
SGIImage::_ReadShort() const
{
        int16 n;
        if (fStream->Read(&n, 2) == 2) {
                return B_BENDIAN_TO_HOST_INT16(n);
        } else
                return 0;
}

// _ReadChar
//
// reads 1 byte from the stream and
// returns it
int8
SGIImage::_ReadChar() const
{
        int8 b;
        ssize_t read = fStream->Read(&b, 1);
        if (read == 1)
                return b;
        else if (read < B_OK)
                return (int8)read;
        return (int8)B_ERROR;
}

// _WriteLong
//
// writes a 32-bit big-endian integer to the stream
status_t
SGIImage::_WriteLong(int32 n) const
{
        int32 bigN = B_HOST_TO_BENDIAN_INT32(n);
        ssize_t written = fStream->Write(&bigN, sizeof(int32));
        if (written == sizeof(int32))
                return B_OK;
        if (written < B_OK)
                return written;
        return B_ERROR;
}

// _WriteShort
//
// writes a 16-bit big-endian integer to the stream
status_t
SGIImage::_WriteShort(uint16 n) const
{
        uint16 bigN = B_HOST_TO_BENDIAN_INT16(n);
        ssize_t written = fStream->Write(&bigN, sizeof(uint16));
        if (written == sizeof(uint16))
                return B_OK;
        if (written < B_OK)
                return written;
        return B_ERROR;
}

// _WriteChar
//
// writes one byte to the stream
status_t
SGIImage::_WriteChar(int8 n) const
{
        ssize_t written = fStream->Write(&n, sizeof(int8));
        if (written == sizeof(int8))
                return B_OK;
        if (written < B_OK)
                return written;
        return B_ERROR;
}

// _ReadRLE8
//
// reads 8-bit RLE data into provided buffer
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_ReadRLE8(uint8* row, int32 numPixels) const
{
        int32 ch;                       // current charater
        uint32 count;           // RLE count
        uint32 length = 0;      // number of bytes read

        uint32 bufferSize = 1024;
        uint8* buffer = new uint8[bufferSize];
        uint32 bufferPos = bufferSize;

        status_t ret = B_OK;

        while (numPixels > 0) {

                // fetch another buffer if we need to
                if (bufferPos >= bufferSize) {
                        ret = fStream->Read(buffer, bufferSize);
                        if (ret < B_OK)
                                break;
                        else
                                bufferPos = 0;
                }

                ch = buffer[bufferPos ++];
                length ++;

                count = ch & 127;
                if (count == 0)
                        break;

                if (ch & 128) {
                        for (uint32 i = 0; i < count; i++) {

                                // fetch another buffer if we need to
                                if (bufferPos >= bufferSize) {
                                        ret = fStream->Read(buffer, bufferSize);
                                        if (ret < B_OK) {
                                                delete[] buffer;
                                                return ret;
                                        } else
                                                bufferPos = 0;
                                }

                                *row = buffer[bufferPos ++];
                                row ++;
                                numPixels --;
                                length ++;
                        }
                } else {

                        // fetch another buffer if we need to
                        if (bufferPos >= bufferSize) {
                                ret = fStream->Read(buffer, bufferSize);
                                if (ret < B_OK) {
                                        delete[] buffer;
                                        return ret;
                                } else
                                        bufferPos = 0;
                        }

                        ch = buffer[bufferPos ++];
                        length ++;
                        for (uint32 i = 0; i < count; i++) {
                                *row = ch;
                                row ++;
                                numPixels --;
                        }
                }
        }
        delete[] buffer;

        return (numPixels > 0 ? ret : length);
}

// _ReadRLE8
//
// reads 8-bit RLE data into provided buffer
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_ReadRLE8(uint8* row, uint8* rleBuffer, int32 numPixels) const
{
        int32 ch;                       // current charater
        uint32 count;           // RLE count
        uint32 length = 0;      // number of bytes read

        if (numPixels <= 0)
                return B_ERROR;

        while (numPixels > 0) {

                ch = *rleBuffer ++;
                length ++;

                count = ch & 127;
                if (count == 0)
                        break;

                if (ch & 128) {
                        for (uint32 i = 0; i < count; i++) {

                                *row = *rleBuffer ++;
                                row ++;
                                numPixels --;
                                length ++;
                        }
                } else {

                        ch = *rleBuffer ++;
                        length ++;
                        for (uint32 i = 0; i < count; i++) {
                                *row = ch;
                                row ++;
                                numPixels --;
                        }
                }
        }

        return length;
}
/*ssize_t
SGIImage::_ReadRLE8(uint8* row, int32 numPixels) const
{
        int32 ch;                       // current charater
        uint32 count;           // RLE count
        uint32 length = 0;      // number of bytes read

        while (numPixels > 0) {
                ch = _ReadChar();
                length ++;

                count = ch & 127;
                if (count == 0)
                        break;

                if (ch & 128) {
                        for (uint32 i = 0; i < count; i++) {
                                *row = _ReadChar();
                                row ++;
                                numPixels --;
                                length ++;
                        }
                } else {
                        ch = _ReadChar();
                        length ++;
                        for (uint32 i = 0; i < count; i++) {
                                *row = ch;
                                row ++;
                                numPixels --;
                        }
                }
        }
        return (numPixels > 0 ? B_ERROR : length);
}*/

// read_and_swap
status_t
read_and_swap(BPositionIO* stream, int16* buffer, uint32 size)
{
        status_t ret = stream->Read(buffer, size);
        if (ret >= B_OK)
                return swap_data(B_INT16_TYPE, buffer, ret, B_SWAP_BENDIAN_TO_HOST);
        return ret;
}

// _ReadRLE16
//
// reads 16-bit RLE data into provided buffer
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_ReadRLE16(uint16* row, int32 numPixels) const
{
        int32 ch;                       // current character
        uint32 count;           // RLE count
        uint32 length = 0;      // number of bytes read...

        uint32 bufferSize = 1024;
        int16* buffer = new int16[bufferSize];
        uint32 bufferPos = bufferSize;
        status_t ret = B_OK;

        while (numPixels > 0) {

                // fetch another buffer if we need to
                if (bufferPos >= bufferSize) {
                        ret = read_and_swap(fStream, buffer, bufferSize * 2);
                        if (ret < B_OK)
                                break;
                        bufferPos = 0;
                }

                ch = buffer[bufferPos ++];
                length ++;

                count = ch & 127;
                if (count == 0)
                        break;

                if (ch & 128) {
                        for (uint32 i = 0; i < count; i++) {

                                // fetch another buffer if we need to
                                if (bufferPos >= bufferSize) {
                                        ret = read_and_swap(fStream, buffer, bufferSize * 2);
                                        if (ret < B_OK) {
                                                delete[] buffer;
                                                return ret;
                                        } else
                                                bufferPos = 0;
                                }

                                *row = B_HOST_TO_BENDIAN_INT16(buffer[bufferPos ++]);
                                row++;
                                numPixels--;
                                length++;
                        }
                } else {

                        // fetch another buffer if we need to
                        if (bufferPos >= bufferSize) {
                                ret = read_and_swap(fStream, buffer, bufferSize * 2);
                                if (ret < B_OK) {
                                        delete[] buffer;
                                        return ret;
                                } else
                                        bufferPos = 0;
                        }

                        ch = B_HOST_TO_BENDIAN_INT16(buffer[bufferPos ++]);
                        length ++;
                        for (uint32 i = 0; i < count; i++) {
                                *row = ch;
                                row++;
                                numPixels--;
                        }
                }
        }
        delete[] buffer;
        return (numPixels > 0 ? ret : length * 2);
}

// _ReadRLE16
//
// reads 16-bit RLE data into provided buffer
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_ReadRLE16(uint16* row, uint16* rleBuffer, int32 numPixels) const
{
        int32 ch;                       // current character
        uint32 count;           // RLE count
        uint32 length = 0;      // number of bytes read...

        if (numPixels <= 0)
                return B_ERROR;

        while (numPixels > 0) {

                ch = *rleBuffer ++;
                length ++;

                count = ch & 127;
                if (count == 0)
                        break;

                if (ch & 128) {
                        for (uint32 i = 0; i < count; i++) {

                                *row = B_HOST_TO_BENDIAN_INT16(*rleBuffer ++);
                                row++;
                                numPixels--;
                                length++;
                        }
                } else {

                        ch = B_HOST_TO_BENDIAN_INT16(*rleBuffer ++);
                        length ++;
                        for (uint32 i = 0; i < count; i++) {
                                *row = ch;
                                row++;
                                numPixels--;
                        }
                }
        }
        return length * 2;
}

// _WriteRLE8
//
// writes 8-bit RLE data into the stream
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_WriteRLE8(uint8* row, int32 numPixels) const
{
        int32 length = 0;       // length of output line
        int32 count;            // number of repeated/non-repeated pixels
        int32 i;                        // looping var
        uint8* start;           // start of sequence
        uint16 repeat;          // repeated pixel


        for (int32 x = numPixels; x > 0;) {
                start = row;
                row   += 2;
                x        -= 2;

                while (x > 0 && (row[-2] != row[-1] || row[-1] != row[0])) {
                        row++;
                        x--;
                }

                row -= 2;
                x   += 2;

                count = row - start;
                while (count > 0) {
                        i        = count > 126 ? 126 : count;
                        count -= i;

                        if (_WriteChar(128 | i) == EOF)
                                return EOF;
                        length ++;

                        while (i > 0) {
                                if (_WriteChar(*start) == EOF)
                                        return EOF;
                                start ++;
                                i --;
                                length ++;
                        }
                }

                if (x <= 0)
                        break;

                start  = row;
                repeat = row[0];

                row ++;
                x --;

                while (x > 0 && *row == repeat) {
                        row ++;
                        x --;
                }

                count = row - start;
                while (count > 0) {
                        i        = count > 126 ? 126 : count;
                        count -= i;

                        if (_WriteChar(i) == EOF)
                                return EOF;
                        length ++;
        
                        if (_WriteChar(repeat) == EOF)
                                return (-1);
                        length ++;
                }
        }

        length ++;

        if (_WriteChar(0) == EOF)
                return EOF;
        else
                return length;
}


// _WriteRLE16
//
// writes 16-bit RLE data into the stream
//
// row                  pointer to buffer for one row
// numPixels    number of pixels that fit into row buffer
ssize_t
SGIImage::_WriteRLE16(uint16* row, int32 numPixels) const
{
        int32 length = 0;       // length of output line
        int32 count;            // number of repeated/non-repeated pixels
        int32 i;                        // looping var
        int32 x;                        // looping var
        uint16* start;          // start of sequence
        uint16 repeat;          // repeated pixel


        for (x = numPixels; x > 0;) {
                start = row;
                row   += 2;
                x        -= 2;

                while (x > 0 && (row[-2] != row[-1] || row[-1] != row[0])) {
                        row ++;
                        x --;
                }

                row -= 2;
                x   += 2;

                count = row - start;
                while (count > 0) {
                        i        = count > 126 ? 126 : count;
                        count -= i;

                        if (_WriteShort(128 | i) == EOF)
                                return EOF;
                        length ++;
        
                        while (i > 0) {
                                if (_WriteShort(*start) == EOF)
                                        return EOF;
                                start ++;
                                i --;
                                length ++;
                        }
                }

                if (x <= 0)
                        break;

                start  = row;
                repeat = row[0];

                row ++;
                x --;

                while (x > 0 && *row == repeat) {
                        row ++;
                        x --;
                }

                count = row - start;
                while (count > 0) {
                        i        = count > 126 ? 126 : count;
                        count -= i;

                        if (_WriteShort(i) == EOF)
                                return EOF;
                        length ++;

                        if (_WriteShort(repeat) == EOF)
                                return EOF;
                        length ++;
                }
        }

        length ++;

        if (_WriteShort(0) == EOF)
                return EOF;
        else
                return (2 * length);
}