AOI_TIFFWriter.cpp

#include "./AOI_TIFFWriter.h"
#include <ACPL/SwapStream.h>
#include <TIFF Library/libtiff/tiffiop.h>
 
using namespace aur;
using namespace aur::ACPL;
 
extern Stream*  gFile;
 
static aur::ExceptionCode WriteTiff( TIFF*& tif, uint8_t compression, uint16_t /* platform */,
                                                           AOI_ColorSpaceEnum colorSpace, uint16_t bitsPerPixel, uint32_t width, uint32_t height,
                                                           float dpiX, float dpiY, const void* imageData )
{
        int     err = 0;
 
        if( tif )
        {
                uint32_t        nrOfPlanes = (uint32_t)AOI_ColorSpaceComponents( colorSpace );
                //
                //      Setup tif
                //
                TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width );
                TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height );
                TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
                TIFFSetField(tif, TIFFTAG_XRESOLUTION, dpiX );
                TIFFSetField(tif, TIFFTAG_YRESOLUTION, dpiY );
                if( colorSpace == AOI_GraySpace )
                        TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, colorSpace == AOI_GraySpace && bitsPerPixel == 8 ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_MINISWHITE );
                else if( colorSpace == AOI_RGBSpace )
                        TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
                else if( colorSpace == AOI_CMYKSpace )
                        TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_SEPARATED);
 
                TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
                TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, nrOfPlanes );
                TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitsPerPixel );
                if(     compression == TIFF_Comp_CCITT )
                        TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4 );
                else if( compression == TIFF_Comp_LZW )
                        TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW );
                else
                        TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE );
                uint32_t        rowsperstrip = TIFFDefaultStripSize( tif, 128 );
                if( rowsperstrip > height )
                        rowsperstrip = height;
                TIFFSetField( tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip );
                //
                //      Process data
                //
                uint8_t*        data = (uint8_t*)imageData;
                uint32_t        rowBytes = ( width * bitsPerPixel * nrOfPlanes + 7 ) / 8;
                for( uint32_t row = 0; row != height; ++row )
                {
                        if( ( err = TIFFWriteScanline( tif, data, row, 0 ) ) < 0 )
                                break;
                        data += rowBytes;
                }
                //
                //      Clean up
                //
                TIFFClose( tif );
        }
        return err;
}
 
::ExceptionCode AOI_WriteTIFF( const aur::ACPL::FileSpec& path, uint8_t compression, uint16_t platform,
                                                          AOI_ColorSpaceEnum colorSpace, uint16_t bitsPerPixel, uint32_t width, uint32_t height,
                                                          float dpiX, float dpiY, const void* imageData )
{
        TIFF* tif = TIFFOpenW( path.GetPOSIXPath(), "w" );
 
        return WriteTiff( tif, compression, platform, colorSpace, bitsPerPixel, width, height, dpiX, dpiY, imageData );
}
 
ExceptionCode   AOI_WriteTIFF( const char16_t* path, uint8_t compression, uint16_t platform,
                                                 AOI_ColorSpaceEnum colorSpace, uint16_t bitsPerPixel, uint32_t width, uint32_t height,
                                                 float dpiX, float dpiY, const void* imageData )
{
        TIFF* tif = TIFFOpenW( ACPL::UString( path ), "w" );
 
        return WriteTiff( tif, compression, platform, colorSpace, bitsPerPixel, width, height, dpiX, dpiY, imageData );
}
 
AOI_TIFFWriter::AOI_TIFFWriter()
{
}
 
AOI_TIFFWriter::~AOI_TIFFWriter()
{
        TIFFClose( mTif );
}
 
::ExceptionCode AOI_TIFFWriter::Init( const aur::ACPL::FileSpec& path, uint8_t compression, uint16_t /* platform */,
                                                                AOI_ColorSpaceEnum colorSpace, uint16_t bitsPerPixel, uint32_t width, uint32_t height,
                                                                float dpiX, float dpiY )
{
        mTif = TIFFOpenW( path.GetPOSIXPath(), "w" );
        if( !mTif )
                return -1;
 
        uint32_t        nrOfPlanes = (uint32_t)AOI_ColorSpaceComponents( colorSpace );
        //
        //      Setup tif
        //
        TIFFSetField(mTif, TIFFTAG_IMAGEWIDTH, width );
        TIFFSetField(mTif, TIFFTAG_IMAGELENGTH, height );
        TIFFSetField(mTif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
        TIFFSetField(mTif, TIFFTAG_XRESOLUTION, dpiX );
        TIFFSetField(mTif, TIFFTAG_YRESOLUTION, dpiY );
        if( colorSpace == AOI_GraySpace )
                TIFFSetField(mTif, TIFFTAG_PHOTOMETRIC, colorSpace == AOI_GraySpace && bitsPerPixel == 8 ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_MINISWHITE );
        else if( colorSpace == AOI_RGBSpace )
                TIFFSetField(mTif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
        else if( colorSpace == AOI_CMYKSpace )
                TIFFSetField(mTif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_SEPARATED);
 
        TIFFSetField(mTif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
        TIFFSetField(mTif, TIFFTAG_SAMPLESPERPIXEL, nrOfPlanes );
        TIFFSetField(mTif, TIFFTAG_BITSPERSAMPLE, bitsPerPixel );
        if(     compression == TIFF_Comp_CCITT )
                TIFFSetField(mTif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4 );
        else if( compression == TIFF_Comp_LZW )
                TIFFSetField(mTif, TIFFTAG_COMPRESSION, COMPRESSION_LZW );
        else
                TIFFSetField(mTif, TIFFTAG_COMPRESSION, COMPRESSION_NONE );
        uint32_t        rowsperstrip = TIFFDefaultStripSize( mTif, 128 );
        if( rowsperstrip > height )
                rowsperstrip = height;
        TIFFSetField( mTif, TIFFTAG_ROWSPERSTRIP, rowsperstrip );
        mWidth = width;
        mBitsPerPixel = bitsPerPixel;
        mNrOfPlanes = nrOfPlanes;
        mHeight = height;
        mRow = 0;
        return 0;
}
 
::ExceptionCode AOI_TIFFWriter::WriteData( uint32_t lines, const void* imageData )
{
        //
        //      Process data
        //
        ::ExceptionCode err;
        uint8_t*        data = (uint8_t*)imageData;
        uint32_t        rowBytes = ( mWidth * mBitsPerPixel * mNrOfPlanes + 7 ) / 8;
        for( uint32_t l = 0; l != lines; ++l )
        {
                if( ( err = TIFFWriteScanline( mTif, data, mRow, 0 ) ) < 0 )
                        break;
                data += rowBytes;
                ++mRow;
        }
        return err < 0;
}