TIFFCompressor.h

/*  IIP TIFF Compressor Class:
    Handles alpha channels, 8 or 16 bit data, ICC profiles and XMP metadata
 
    Copyright (C) 2024-2025 Ruven Pillay
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 
*/
 
 
#ifndef _TIFFCOMPRESSOR_H
#define _TIFFCOMPRESSOR_H
 
 
#include "Compressor.h"
#include <tiffio.h>
 
 
 
typedef struct {
  unsigned char *buffer;   
  toff_t current;          
  toff_t end;              
  toff_t capacity;         
} tiff_mem;
 
typedef tiff_mem* tiff_mem_ptr;
 
 
 
class TIFFCompressor: public Compressor {
 
 private:
 
  unsigned int height;
  tiff_mem dest;
  TIFF *tiff;
 
  unsigned int chunk_size;        
  size_t current_chunk;           
 
  uint16_t compression;
  
  void writeMetadata();
 
  void writeResolution();
 
  void writeICCProfile();
 
  void writeXMPMetadata();
 
  void configure( const RawTile& );
 
 
 public:
 
 
  TIFFCompressor( int compression, int quality ) : Compressor(quality), height(0), tiff(NULL)
  {
    this->setCompression( compression );
 
    // Limit our quality level to the max allowed for Deflate and ZStandard
    if( compression == 2 && Q > 9 ) Q = 9;
    else if( compression == 5 && Q > 19 ) Q = 19;
  };
 
 
 
 
  inline void setCompression( int compression )
  {
    if      ( compression == 1 ) this->compression = COMPRESSION_LZW;
    else if ( compression == 2 ) this->compression = COMPRESSION_ADOBE_DEFLATE;
    else if ( compression == 3 ) this->compression = COMPRESSION_JPEG;
    else if ( compression == 4 ) this->compression = COMPRESSION_WEBP;
    else if ( compression == 5 ) this->compression = COMPRESSION_ZSTD;
    else                         this->compression = COMPRESSION_NONE;
  };
 
 
 
  inline void setQuality( int quality )
  {
    // Flag that user has manually changed quality level
    default_quality = false;
 
    Q = quality;
 
    // Set max depending on compression type    
    int max;
    if( compression == COMPRESSION_ADOBE_DEFLATE ) max = 9;   // Max for deflate is 9
    else if( compression == COMPRESSION_ZSTD )     max = 19;  // Max for zstd is 19
    else max = 100;                                           // Max for JPEG or WebP is 100
 
    // Limit quality range
    if     ( Q < 0 )   Q = 0;
    else if( Q > max ) Q = max;
 
  };
 
 
 
  void InitCompression( const RawTile& rawtile, unsigned int strip_height );
 
 
 
  unsigned int CompressStrip( unsigned char* source, unsigned char* output, unsigned int tile_height );
 
 
 
 
  unsigned int Finish( unsigned char* output );
 
 
 
  unsigned int Compress( RawTile& t );
 
 
  inline const char* getMimeType() const { return "image/tiff"; };
 
  inline const char* getSuffix() const { return "tif"; };
 
  inline ImageEncoding getImageEncoding() const { return ImageEncoding::TIFF; };
 
 
 
  static inline std::string getCompressionName( int code )
  {
    std::string name;
    if     ( code == 1 ) name = "LZW";
    else if( code == 2 ) name = "Deflate";
    else if( code == 3 ) name = "JPEG";
    else if( code == 4 ) name = "WebP";
    else if( code == 5 ) name = "ZSTD";
    else                 name = "None";
    return name;
  };
 
};
 
#endif