/*
 * Copyright 2003-2009, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Michael Wilber
 *              Stephan Aßmus <stippi@yellowbites.com> (write support)
 */


#include "TIFFTranslator.h"
#include "TIFFView.h"

#define TIFF_DISABLE_DEPRECATED
#include "tiffio.h"

#if __GNUC__ == 2
#define TIFF_UINT32_TYPE uint32
#else
#define TIFF_UINT32_TYPE uint32_t
#endif

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


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TIFFTranslator"


/*!
        How this works:

        libtiff has a special version of TIFFOpen() that gets passed custom
        functions for reading writing etc. and a handle. This handle in our case
        is a BPositionIO object, which libtiff passes on to the functions for reading
        writing etc. So when operations are performed on the TIFF* handle that is
        returned by TIFFOpen(), libtiff uses the special reading writing etc
        functions so that all stream io happens on the BPositionIO object.
*/


// The input formats that this translator supports.
static const translation_format sInputFormats[] = {
        {
                B_TRANSLATOR_BITMAP,
                B_TRANSLATOR_BITMAP,
                BBT_IN_QUALITY,
                BBT_IN_CAPABILITY,
                "image/x-be-bitmap",
                "Be Bitmap Format (TIFFTranslator)"
        },
        {
                B_TIFF_FORMAT,
                B_TRANSLATOR_BITMAP,
                TIFF_IN_QUALITY,
                TIFF_IN_CAPABILITY,
                "image/tiff",
                "TIFF image"
        }
};

// The output formats that this translator supports.
static const translation_format sOutputFormats[] = {
        {
                B_TRANSLATOR_BITMAP,
                B_TRANSLATOR_BITMAP,
                BBT_OUT_QUALITY,
                BBT_OUT_CAPABILITY,
                "image/x-be-bitmap",
                "Be Bitmap Format (TIFFTranslator)"
        },
        {
                B_TIFF_FORMAT,
                B_TRANSLATOR_BITMAP,
                TIFF_OUT_QUALITY,
                TIFF_OUT_CAPABILITY,
                "image/tiff",
                "TIFF image"
        }
};

// Default settings for the Translator
static const TranSetting sDefaultSettings[] = {
        {B_TRANSLATOR_EXT_HEADER_ONLY, TRAN_SETTING_BOOL, false},
        {B_TRANSLATOR_EXT_DATA_ONLY, TRAN_SETTING_BOOL, false},
        {TIFF_SETTING_COMPRESSION, TRAN_SETTING_INT32, COMPRESSION_LZW}
                // Compression is LZW by default
};

const uint32 kNumInputFormats = sizeof(sInputFormats) / sizeof(translation_format);
const uint32 kNumOutputFormats = sizeof(sOutputFormats) / sizeof(translation_format);
const uint32 kNumDefaultSettings = sizeof(sDefaultSettings) / sizeof(TranSetting);


// ---------------------------------------------------------------
// make_nth_translator
//
// Creates a TIFFTranslator object to be used by BTranslatorRoster
//
// Preconditions:
//
// Parameters: n,               The translator to return. Since
//                                              TIFFTranslator only publishes one
//                                              translator, it only returns a
//                                              TIFFTranslator if n == 0
//
//             you,     The image_id of the add-on that
//                                              contains code (not used).
//
//             flags,   Has no meaning yet, should be 0.
//
// Postconditions:
//
// Returns: NULL if n is not zero,
//          a new TIFFTranslator if n is zero
// ---------------------------------------------------------------
BTranslator *
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
        if (!n)
                return new TIFFTranslator();
        else
                return NULL;
}


//// libtiff Callback functions!

BPositionIO *
tiff_get_pio(thandle_t stream)
{
        BPositionIO *pio = NULL;
        pio = static_cast<BPositionIO *>(stream);
        if (!pio)
                debugger("pio is NULL");

        return pio;
}

tsize_t
tiff_read_proc(thandle_t stream, tdata_t buf, tsize_t size)
{
        return tiff_get_pio(stream)->Read(buf, size);
}

tsize_t
tiff_write_proc(thandle_t stream, tdata_t buf, tsize_t size)
{
        return tiff_get_pio(stream)->Write(buf, size);
}

toff_t
tiff_seek_proc(thandle_t stream, toff_t off, int whence)
{
        return tiff_get_pio(stream)->Seek(off, whence);
}

int
tiff_close_proc(thandle_t stream)
{
        tiff_get_pio(stream)->Seek(0, SEEK_SET);
        return 0;
}

toff_t
tiff_size_proc(thandle_t stream)
{
        BPositionIO *pio = tiff_get_pio(stream);
        off_t cur, end;
        cur = pio->Position();
        end = pio->Seek(0, SEEK_END);
        pio->Seek(cur, SEEK_SET);

        return end;
}

int
tiff_map_file_proc(thandle_t stream, tdata_t *pbase, toff_t *psize)
{
        // BeOS doesn't support mmap() so just return 0
        return 0;
}

void
tiff_unmap_file_proc(thandle_t stream, tdata_t base, toff_t size)
{
        return;
}


status_t
identify_tiff_header(BPositionIO *inSource, BMessage *ioExtension,
        translator_info *outInfo, uint32 outType, TIFF **poutTIFF = NULL)
{
        // get TIFF handle
        TIFF* tif = TIFFClientOpen("TIFFTranslator", "r", inSource,
                tiff_read_proc, tiff_write_proc, tiff_seek_proc, tiff_close_proc,
                tiff_size_proc, tiff_map_file_proc, tiff_unmap_file_proc);
        if (!tif)
                return B_NO_TRANSLATOR;

        // count number of documents
        int32 documentCount = 0, documentIndex = 1;
        do {
                documentCount++;
        } while (TIFFReadDirectory(tif));

        if (ioExtension) {
                // Check if a document index has been specified
                if (ioExtension->FindInt32(DOCUMENT_INDEX, &documentIndex) != B_OK)
                        documentIndex = 1;

                if (documentIndex < 1 || documentIndex > documentCount) {
                        // document index is invalid
                        fputs(B_TRANSLATE("identify_tiff_header: invalid "
                                "document index\n"), stderr);
                        return B_NO_TRANSLATOR;
                }
        }

        // identify the document the user specified or the first document
        // if the user did not specify which document they wanted to identify
        if (!TIFFSetDirectory(tif, documentIndex - 1)) {
                fputs(B_TRANSLATE("identify_tiff_header: couldn't set "
                        "directory\n"), stderr);
                return B_NO_TRANSLATOR;
        }

        if (ioExtension) {
                // add page count to ioExtension
                ioExtension->RemoveName(DOCUMENT_COUNT);
                ioExtension->AddInt32(DOCUMENT_COUNT, documentCount);
        }

        if (outInfo) {
                outInfo->type = B_TIFF_FORMAT;
                outInfo->group = B_TRANSLATOR_BITMAP;
                outInfo->quality = TIFF_IN_QUALITY;
                outInfo->capability = TIFF_IN_CAPABILITY;
                strcpy(outInfo->MIME, "image/tiff");
                strlcpy(outInfo->name, B_TRANSLATE("TIFF image"),
                        sizeof(outInfo->name));
        }

        if (!poutTIFF) {
                // close TIFF if caller is not interested in TIFF handle
                TIFFClose(tif);
        } else {
                // leave TIFF open and return handle if caller needs it
                *poutTIFF = tif;
        }

        return B_OK;
}


// How this works:
// Following are a couple of functions,
//
// convert_buffer_*   to convert a buffer in place to the TIFF native format
//
// convert_buffers_*  to convert from one buffer to another to the TIFF
//                    native format, additionally compensating for padding bytes
//                    I don't know if libTIFF can be set up to respect padding bytes,
//                    otherwise this whole thing could be simplified a bit.
//
// Additionally, there are two functions convert_buffer() and convert_buffers() that take
// a color_space as one of the arguments and pick the correct worker functions from there.
// This way I don't write any code more than once, for easier debugging and maintainance.


// convert_buffer_bgra_rgba
inline void
convert_buffer_bgra_rgba(uint8* buffer, uint32 rows, uint32 width,
        uint32 bytesPerRow)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* handle = buffer;
                for (uint32 x = 0; x < width; x++) {
                        uint8 temp = handle[0];
                        handle[0] = handle[2];
                        handle[2] = temp;
                        handle += 4;
                }
                buffer += bytesPerRow;
        }
}

// convert_buffer_argb_rgba
inline void
convert_buffer_argb_rgba(uint8* buffer, uint32 rows, uint32 width,
        uint32 bytesPerRow)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* handle = buffer;
                for (uint32 x = 0; x < width; x++) {
                        uint8 temp = handle[0];
                        handle[0] = handle[1];
                        handle[1] = handle[2];
                        handle[2] = handle[3];
                        handle[3] = temp;
                        handle += 4;
                }
                buffer += bytesPerRow;
        }
}

// convert_buffers_bgra_rgba
inline void
convert_buffers_bgra_rgba(uint8* inBuffer, uint8* outBuffer, uint32 rows,
        uint32 width, uint32 bytesPerRow)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* inHandle = inBuffer;
                uint8* outHandle = outBuffer;
                for (uint32 x = 0; x < width; x++) {
                        outHandle[0] = inHandle[2];
                        outHandle[1] = inHandle[1];
                        outHandle[2] = inHandle[0];
                        outHandle[3] = inHandle[3];
                        inHandle += 4;
                        outHandle += 4;
                }
                inBuffer += bytesPerRow;
                outBuffer += width * 4;
        }
}

// convert_buffers_argb_rgba
inline void
convert_buffers_argb_rgba(uint8* inBuffer, uint8* outBuffer, uint32 rows,
        uint32 width, uint32 bytesPerRow)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* inHandle = inBuffer;
                uint8* outHandle = outBuffer;
                for (uint32 x = 0; x < width; x++) {
                        outHandle[0] = inHandle[1];
                        outHandle[1] = inHandle[2];
                        outHandle[2] = inHandle[3];
                        outHandle[3] = inHandle[0];
                        inHandle += 4;
                        outHandle += 4;
                }
                inBuffer += bytesPerRow;
                outBuffer += width * 4;
        }
}

// convert_buffers_bgrX_rgb
inline void
convert_buffers_bgrX_rgb(uint8* inBuffer, uint8* outBuffer, uint32 rows,
        uint32 width, uint32 bytesPerRow, uint32 samplesPerPixel)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* inHandle = inBuffer;
                uint8* outHandle = outBuffer;
                for (uint32 x = 0; x < width; x++) {
                        // the usage of temp is just in case inBuffer == outBuffer
                        // (see convert_buffer() for B_RGB24)
                        uint8 temp = inHandle[0];
                        outHandle[0] = inHandle[2];
                        outHandle[1] = inHandle[1];
                        outHandle[2] = temp;
                        inHandle += samplesPerPixel;
                        outHandle += 3;
                }
                inBuffer += bytesPerRow;
                outBuffer += width * 3;
        }
}

// convert_buffers_rgbX_rgb
inline void
convert_buffers_rgbX_rgb(uint8* inBuffer, uint8* outBuffer, uint32 rows,
        uint32 width, uint32 bytesPerRow, uint32 samplesPerPixel)
{
        for (uint32 y = 0; y < rows; y++) {
                uint8* inHandle = inBuffer;
                uint8* outHandle = outBuffer;
                for (uint32 x = 0; x < width; x++) {
                        outHandle[0] = inHandle[0];
                        outHandle[1] = inHandle[1];
                        outHandle[2] = inHandle[2];
                        inHandle += samplesPerPixel;
                        outHandle += 3;
                }
                inBuffer += bytesPerRow;
                outBuffer += width * 3;
        }
}


// convert_buffers_cmap
inline void
convert_buffers_cmap(uint8* inBuffer, uint8* outBuffer, uint32 rows,
        uint32 width, uint32 bytesPerRow)
{
        // compensate for bytesPerRow != width (padding bytes)
        // this function will not be called if bytesPerRow == width, btw
        for (uint32 y = 0; y < rows; y++) {
                _TIFFmemcpy(outBuffer, inBuffer, width);
                inBuffer += bytesPerRow;
                outBuffer += width;
        }
}

// convert_buffer
inline void
convert_buffer(color_space format, uint8* buffer, uint32 rows, uint32 width,
        uint32 bytesPerRow)
{
        switch (format) {
                case B_RGBA32:
                        convert_buffer_bgra_rgba(buffer, rows, width, bytesPerRow);
                        break;
                case B_RGBA32_BIG:
                        convert_buffer_argb_rgba(buffer, rows, width, bytesPerRow);
                        break;
//              case B_RGB32:
//              case B_RGB32_BIG:
//                      these two cannot be encountered, since inBufferSize != bytesPerStrip
//                      (we're stripping the unused "alpha" channel 32->24 bits)
                case B_RGB24:
                        convert_buffers_bgrX_rgb(buffer, buffer, rows, width, bytesPerRow, 3);
                        break;
//              case B_RGB24_BIG:
                        // buffer already has the correct format
                        break;
//              case B_CMAP8:
//              case B_GRAY8:
                        // buffer already has the correct format
                        break;
                default:
                        break;
        }
}

// convert_buffers
inline void
convert_buffers(color_space format, uint8* inBuffer, uint8* outBuffer,
        uint32 rows, uint32 width, uint32 bytesPerRow)
{
        switch (format) {
                case B_RGBA32:
                        convert_buffers_bgra_rgba(inBuffer, outBuffer, rows, width, bytesPerRow);
                        break;
                case B_RGBA32_BIG:
                        convert_buffers_argb_rgba(inBuffer, outBuffer, rows, width, bytesPerRow);
                        break;
                case B_RGB32:
                        convert_buffers_bgrX_rgb(inBuffer, outBuffer, rows, width, bytesPerRow, 4);
                        break;
                case B_RGB32_BIG:
                        convert_buffers_rgbX_rgb(inBuffer, outBuffer, rows, width, bytesPerRow, 4);
                        break;
                case B_RGB24:
                        convert_buffers_bgrX_rgb(inBuffer, outBuffer, rows, width, bytesPerRow, 3);
                        break;
                case B_RGB24_BIG:
                        convert_buffers_rgbX_rgb(inBuffer, outBuffer, rows, width, bytesPerRow, 3);
                        break;
                case B_CMAP8:
                case B_GRAY8:
                        convert_buffers_cmap(inBuffer, outBuffer, rows, width, bytesPerRow);
                        break;
                default:
                        break;
        }
}

// Sets up any additional TIFF fields for the color spaces it supports,
// determines if it needs one or two buffers to carry out any conversions,
// uses the various convert routines above to do the actual conversion,
// writes complete strips of data plus one strip of remaining data.
//
// write_tif_stream
status_t
write_tif_stream(TIFF* tif, BPositionIO* inSource, color_space format,
                                 uint32 width, uint32 height, uint32 bytesPerRow,
                                 uint32 rowsPerStrip, uint32 dataSize)
{
        uint32 bytesPerStrip = 0;

        // set up the TIFF fields about what channels we write
        switch (format) {
                case B_RGBA32:
                case B_RGBA32_BIG:
                        uint16 extraSamples[1];
                        extraSamples[0] = EXTRASAMPLE_UNASSALPHA;
                        TIFFSetField(tif, TIFFTAG_EXTRASAMPLES, 1, extraSamples);
                        TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 4);
                        // going to write rgb + alpha channels
                        bytesPerStrip = width * 4 * rowsPerStrip;
                        break;
                case B_RGB32:
                case B_RGB32_BIG:
                case B_RGB24:
                case B_RGB24_BIG:
                        TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
                        // going to write just the rgb channels
                        bytesPerStrip = width * 3 * rowsPerStrip;
                        break;
                case B_CMAP8:
                case B_GRAY8:
                        bytesPerStrip = width * rowsPerStrip;
                        break;
                default:
                        return B_BAD_VALUE;
        }

        uint32 remaining = dataSize;
        status_t ret = B_OK;
        // Write the information to the stream
        uint32 inBufferSize = bytesPerRow * rowsPerStrip;
        // allocate intermediate input buffer
        uint8* inBuffer = (uint8*)_TIFFmalloc(inBufferSize);
        ssize_t read, written = B_ERROR;
        // bytesPerStrip is the size of the buffer that libtiff expects to write per strip
        // it might be different to the size of the input buffer,
        // if that one contains padding bytes at the end of each row
        if (inBufferSize != bytesPerStrip) {
                // allocate a second buffer
                // (two buffers are needed since padding bytes have to be compensated for)
                uint8* outBuffer = (uint8*)_TIFFmalloc(bytesPerStrip);
                if (inBuffer && outBuffer) {
//printf("using two buffers\n");
                        read = inSource->Read(inBuffer, inBufferSize);
                        uint32 stripIndex = 0;
                        while (read == (ssize_t)inBufferSize) {
//printf("writing bytes: %ld (strip: %ld)\n", read, stripIndex);
                                // convert the buffers (channel order) and compensate
                                // for bytesPerRow != samplesPerRow (padding bytes)
                                convert_buffers(format, inBuffer, outBuffer,
                                                                rowsPerStrip, width, bytesPerRow);
                                // let libtiff write the encoded strip to the BPositionIO
                                written = TIFFWriteEncodedStrip(tif, stripIndex, outBuffer, bytesPerStrip);
                                stripIndex++;
                                if (written < B_OK)
                                        break;
                                remaining -= inBufferSize;
                                read = inSource->Read(inBuffer, min_c(inBufferSize, remaining));
                        }
                        // write the rest of the remaining rows
                        if (read < (ssize_t)inBufferSize && read > 0) {
//printf("writing remaining bytes: %ld\n", read);
                                // convert the buffers (channel order) and compensate
                                // for bytesPerRow != samplesPerRow (padding bytes)
                                convert_buffers(format, inBuffer, outBuffer,
                                                                read / bytesPerRow, width, bytesPerRow);
                                // let libtiff write the encoded strip to the BPositionIO
                                written = TIFFWriteEncodedStrip(tif, stripIndex, outBuffer, read);
                                remaining -= read;
                        }
                } else
                        ret = B_NO_MEMORY;
                // clean up output buffer
                if (outBuffer)
                        _TIFFfree(outBuffer);
        } else {
//printf("using one buffer\n");
                // the input buffer is all we need, we convert it in place
                if (inBuffer) {
                        read = inSource->Read(inBuffer, inBufferSize);
                        uint32 stripIndex = 0;
                        while (read == (ssize_t)inBufferSize) {
//printf("writing bytes: %ld (strip: %ld)\n", read, stripIndex);
                                // convert the buffer (channel order)
                                convert_buffer(format, inBuffer,
                                                           rowsPerStrip, width, bytesPerRow);
                                // let libtiff write the encoded strip to the BPositionIO
                                written = TIFFWriteEncodedStrip(tif, stripIndex, inBuffer, bytesPerStrip);
                                stripIndex++;
                                if (written < 0)
                                        break;
                                remaining -= inBufferSize;
                                read = inSource->Read(inBuffer, min_c(inBufferSize, remaining));
                        }
                        // write the rest of the remaining rows
                        if (read < (ssize_t)inBufferSize && read > 0) {
//printf("writing remaining bytes: %ld (strip: %ld)\n", read, stripIndex);
                                // convert the buffers (channel order) and compensate
                                // for bytesPerRow != samplesPerRow (padding bytes)
                                convert_buffer(format, inBuffer,
                                                           read / bytesPerRow, width, bytesPerRow);
                                // let libtiff write the encoded strip to the BPositionIO
                                written = TIFFWriteEncodedStrip(tif, stripIndex, inBuffer, read);
                                remaining -= read;
                        }
                } else
                        ret = B_NO_MEMORY;
        }
        // clean up input buffer
        if (inBuffer)
                _TIFFfree(inBuffer);
        // see if there was an error reading or writing the streams
        if (remaining > 0)
                // "written" may contain a more specific error
                ret = written < 0 ? written : B_ERROR;
        else
                ret = B_OK;

        return ret;
}


//      #pragma mark -


TIFFTranslator::TIFFTranslator()
        : BaseTranslator(B_TRANSLATE("TIFF images"),
                B_TRANSLATE("TIFF image translator"),
                TIFF_TRANSLATOR_VERSION,
                sInputFormats, kNumInputFormats,
                sOutputFormats, kNumOutputFormats,
                "TIFFTranslator_Settings",
                sDefaultSettings, kNumDefaultSettings,
                B_TRANSLATOR_BITMAP, B_TIFF_FORMAT)
{
        // TODO: for now!
        TIFFSetErrorHandler(NULL);
}


TIFFTranslator::~TIFFTranslator()
{
}


status_t
TIFFTranslator::DerivedIdentify(BPositionIO *inSource,
        const translation_format *inFormat, BMessage *ioExtension,
        translator_info *outInfo, uint32 outType)
{
        return identify_tiff_header(inSource, ioExtension, outInfo, outType);
}


status_t
TIFFTranslator::translate_from_bits(BPositionIO *inSource, uint32 outType,
        BPositionIO *outDestination)
{
        TranslatorBitmap bitsHeader;

        uint32 compression = fSettings->SetGetInt32(TIFF_SETTING_COMPRESSION);

        status_t result;
        result = identify_bits_header(inSource, NULL, &bitsHeader);
        if (result != B_OK)
                return result;

        // Translate B_TRANSLATOR_BITMAP to B_TIFF_FORMAT
        if (outType == B_TIFF_FORMAT) {
                // Set up TIFF header

                // get TIFF handle
                TIFF* tif = TIFFClientOpen("TIFFTranslator", "w", outDestination,
                        tiff_read_proc, tiff_write_proc, tiff_seek_proc, tiff_close_proc,
                        tiff_size_proc, tiff_map_file_proc, tiff_unmap_file_proc);
                if (!tif)
                        return B_NO_TRANSLATOR;

                // common fields which are independent of the bitmap format
                uint32 width = bitsHeader.bounds.IntegerWidth() + 1;
                uint32 height = bitsHeader.bounds.IntegerHeight() + 1;
                uint32 dataSize = bitsHeader.dataSize;
                uint32 bytesPerRow = bitsHeader.rowBytes;

                TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
                TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
                TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
/*const char* compressionString = NULL;
switch (compression) {
        case COMPRESSION_NONE:
                compressionString = "None";
                break;
        case COMPRESSION_PACKBITS:
                compressionString = "RLE";
                break;
        case COMPRESSION_DEFLATE:
                compressionString = "Deflate";
                break;
        case COMPRESSION_LZW:
                compressionString = "LZW";
                break;
        case COMPRESSION_JPEG:
                compressionString = "JPEG";
                break;
        case COMPRESSION_JP2000:
                compressionString = "JPEG2000";
                break;
}
if (compressionString)
printf("using compression: %s\n", compressionString);
else
printf("using unkown compression (%ld).\n", compression);
*/
                TIFFSetField(tif, TIFFTAG_COMPRESSION, compression);

                // TODO: some extra fields that should also get some special attention
                TIFFSetField(tif, TIFFTAG_XRESOLUTION, 150.0);
                TIFFSetField(tif, TIFFTAG_YRESOLUTION, 150.0);
                TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);

                // we are going to write XX row(s) of pixels (lines) per strip
                uint32 rowsPerStrip = TIFFDefaultStripSize(tif, 0);
//printf("recommended rows per strip: %ld\n", TIFFDefaultStripSize(tif, 0));
                TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsPerStrip);

                status_t ret = B_OK;
                // set the rest of the fields according to the bitmap format
                switch (bitsHeader.colors) {

                        // Output to 32-bit True Color TIFF (8 bits alpha)
                        case B_RGBA32:
                        case B_RGB32:
                        case B_RGB24:
                        case B_RGBA32_BIG:
                        case B_RGB32_BIG:
                        case B_RGB24_BIG:
                                // set the fields specific to this color space
                                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
                                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
//                              TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
                                // write the tiff stream
                                ret = write_tif_stream(tif, inSource, bitsHeader.colors,
                                                                           width, height, bytesPerRow,
                                                                           rowsPerStrip, dataSize);
                                break;
/*
                        case B_CMYA32:
                                break;

                        // Output to 15-bit True Color TIFF
                        case B_RGB15:
                        case B_RGB15_BIG:
                                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 5);
                                TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
                                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
                                bytesPerStrip = width * 2 * rowsPerStrip;
                                break;
*/
                        // Output to 8-bit Color Mapped TIFF 32 bits per color map entry
                        case B_CMAP8: {
                                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE);
                                TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
                                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
                                // convert the system palette to 16 bit values for libtiff
                                const color_map *map = system_colors();
                                if (map) {
                                        uint16 red[256];
                                        uint16 green[256];
                                        uint16 blue[256];
                                        for (uint32 i = 0; i < 256; i++) {
                                                // scale 8 bits to 16 bits
                                                red[i] = map->color_list[i].red * 256 + map->color_list[i].red;
                                                green[i] = map->color_list[i].green * 256 + map->color_list[i].green;
                                                blue[i] = map->color_list[i].blue * 256 + map->color_list[i].blue;
                                        }
                                        TIFFSetField(tif, TIFFTAG_COLORMAP, &red, &green, &blue);
                                        // write the tiff stream
                                        ret = write_tif_stream(tif, inSource, bitsHeader.colors,
                                                                                   width, height, bytesPerRow,
                                                                                   rowsPerStrip, dataSize);
                                } else
                                        ret = B_ERROR;
                                break;
                        }
                        // Output to 8-bit Black and White TIFF
                        case B_GRAY8:
                                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
                                TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
                                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
                                ret = write_tif_stream(tif, inSource, bitsHeader.colors,
                                                                           width, height, bytesPerRow,
                                                                           rowsPerStrip, dataSize);
                                break;

/*                      // Output to 1-bit Black and White TIFF
                        case B_GRAY1:
                                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 1);
                                TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 8);
                                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
                                bytesPerStrip = ((width + 7) / 8) * rowsPerStrip;
                                break;
*/
                        default:
                                ret = B_NO_TRANSLATOR;
                }
                // Close the handle
                TIFFClose(tif);
                return ret;

        } else
                return B_NO_TRANSLATOR;
}

status_t
TIFFTranslator::translate_from_tiff(BPositionIO *inSource, BMessage *ioExtension,
        uint32 outType, BPositionIO *outDestination)
{
        status_t result = B_NO_TRANSLATOR;

        bool bheaderonly = false, bdataonly = false;
                // Always write out the entire image. Some programs
                // fail when given "headerOnly", even though they requested it.
                // These settings are not applicable when outputting TIFFs

        // variables needing cleanup
        TIFF *ptif = NULL;
        uint32 *praster = NULL;

        status_t ret;
        ret = identify_tiff_header(inSource, ioExtension, NULL, outType, &ptif);

        if (outType == B_TIFF_FORMAT && ret == B_OK && ptif) {
                // if translating from TIFF to TIFF,
                // just write out the entire TIFF
                TIFFClose(ptif);
                translate_direct_copy(inSource, outDestination);
                return B_OK;
        }

        while (ret == B_OK && ptif) {
                // use while / break not for looping, but for
                // cleaner goto like capability

                ret = B_ERROR;
                        // make certain there is no looping

                uint32 width = 0, height = 0;
                if (!TIFFGetField(ptif, TIFFTAG_IMAGEWIDTH, &width)) {
                        result = B_NO_TRANSLATOR;
                        break;
                }
                if (!TIFFGetField(ptif, TIFFTAG_IMAGELENGTH, &height)) {
                        result = B_NO_TRANSLATOR;
                        break;
                }
                size_t npixels = 0;
                npixels = width * height;
                praster = static_cast<uint32 *>(_TIFFmalloc(npixels * 4));
                if (praster && TIFFReadRGBAImage(ptif, width, height, (TIFF_UINT32_TYPE*)praster, 0)) {
                        if (!bdataonly) {
                                // Construct and write Be bitmap header
                                TranslatorBitmap bitsHeader;
                                bitsHeader.magic = B_TRANSLATOR_BITMAP;
                                bitsHeader.bounds.left = 0;
                                bitsHeader.bounds.top = 0;
                                bitsHeader.bounds.right = width - 1;
                                bitsHeader.bounds.bottom = height - 1;
                                bitsHeader.rowBytes = 4 * width;
                                bitsHeader.colors = B_RGBA32;
                                bitsHeader.dataSize = bitsHeader.rowBytes * height;
                                if (swap_data(B_UINT32_TYPE, &bitsHeader,
                                        sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN) != B_OK) {
                                        result = B_ERROR;
                                        break;
                                }
                                outDestination->Write(&bitsHeader, sizeof(TranslatorBitmap));
                        }

                        if (!bheaderonly) {
                                // Convert raw RGBA data to B_RGBA32 colorspace
                                // and write out the results
                                uint8 *pbitsrow = new uint8[width * 4];
                                if (!pbitsrow) {
                                        result = B_NO_MEMORY;
                                        break;
                                }
                                uint8 *pras8 = reinterpret_cast<uint8 *>(praster);
                                for (uint32 i = 0; i < height; i++) {
                                        uint8 *pbits, *prgba;
                                        pbits = pbitsrow;
                                        prgba = pras8 + ((height - (i + 1)) * width * 4);

                                        for (uint32 k = 0; k < width; k++) {
                                                pbits[0] = prgba[2];
                                                pbits[1] = prgba[1];
                                                pbits[2] = prgba[0];
                                                pbits[3] = prgba[3];
                                                pbits += 4;
                                                prgba += 4;
                                        }

                                        outDestination->Write(pbitsrow, width * 4);
                                }
                                delete[] pbitsrow;
                                pbitsrow = NULL;
                        }

                        result = B_OK;
                        break;

                } // if (praster && TIFFReadRGBAImage(ptif, width, height, praster, 0))

        } // while (ret == B_OK && ptif)

        if (praster) {
                _TIFFfree(praster);
                praster = NULL;
        }
        if (ptif) {
                TIFFClose(ptif);
                ptif = NULL;
        }

        return result;
}

// ---------------------------------------------------------------
// DerivedTranslate
//
// Translates the data in inSource to the type outType and stores
// the translated data in outDestination.
//
// Preconditions:
//
// Parameters:  inSource,       the data to be translated
//
//                              inInfo, hint about the data in inSource (not used)
//
//                              ioExtension,    configuration options for the
//                                                              translator
//
//                              outType,        the type to convert inSource to
//
//                              outDestination, where the translated data is
//                                                              put
//
//                              baseType, indicates whether inSource is in the
//                                        bits format, not in the bits format or
//                                        is unknown
//
// Postconditions:
//
// Returns: B_BAD_VALUE, if the options in ioExtension are bad
//
// B_NO_TRANSLATOR, if this translator doesn't understand the data
//
// B_ERROR, if there was an error allocating memory or converting
//          data
//
// B_OK, if all went well
// ---------------------------------------------------------------
status_t
TIFFTranslator::DerivedTranslate(BPositionIO *inSource,
                const translator_info *inInfo, BMessage *ioExtension,
                uint32 outType, BPositionIO *outDestination, int32 baseType)
{
        if (baseType == 1)
                // if inSource is in bits format
                return translate_from_bits(inSource, outType, outDestination);
        else if (baseType == 0)
                // if inSource is NOT in bits format
                return translate_from_tiff(inSource, ioExtension, outType, outDestination);
        else
                // if BaseTranslator did not properly identify the data as
                // bits or not bits
                return B_NO_TRANSLATOR;
}

BView *
TIFFTranslator::NewConfigView(TranslatorSettings *settings)
{
        return new TIFFView(B_TRANSLATE("TIFFTranslator Settings"),
                B_WILL_DRAW, settings);
}