RawTile.h

 
 
/*  IIPImage Server
 
    Copyright (C) 2000-2023 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 _RAWTILE_H
#define _RAWTILE_H
#include <cstring>
#include <string>
#include <cstdlib>
#include <ctime>
 
#if !( (__cplusplus >= 201103L) || ((defined(_MSC_VER) && _MSC_VER >= 1900)) )
#include <stdint.h>          // Required for C++98
#endif
 
 
enum ColourSpaces { NONE, GREYSCALE, sRGB, CIELAB, BINARY };
 
enum CompressionType { UNCOMPRESSED, JPEG, DEFLATE, PNG, WEBP };
 
enum SampleType { FIXEDPOINT, FLOATINGPOINT };
 
 
 
class RawTile {
 
 public:
 
  std::string filename;
 
  unsigned int width;
 
  unsigned int height;
 
  int channels;
 
  int bpc;
 
  SampleType sampleType;
 
  CompressionType compressionType;
 
  int quality;
 
  time_t timestamp;
 
  int tileNum;
 
  int resolution;
 
  int hSequence;
 
  int vSequence;
 
  uint32_t capacity;
 
  uint32_t dataLength;
 
 
  int memoryManaged;
 
  void *data;
 
 
 
  RawTile( int tn = 0, int res = 0, int hs = 0, int vs = 0,
           int w = 0, int h = 0, int c = 0, int b = 0 )
    : width( w ),
      height( h ),
      channels( c ),
      bpc( b ),
      sampleType( FIXEDPOINT ),
      compressionType( UNCOMPRESSED ),
      quality( 0 ),
      timestamp( 0 ),
      tileNum( tn ),
      resolution( res ),
      hSequence( hs ),
      vSequence( vs ),
      capacity( 0 ),
      dataLength( 0 ),
      memoryManaged( 1 ),
      data( NULL ) {};
 
 
 
  ~RawTile() {
    if( memoryManaged ) deallocate( data );
  }
 
 
 
  RawTile( const RawTile& tile )
    : filename( tile.filename ),
      width( tile.width ),
      height( tile.height ),
      channels( tile.channels ),
      bpc( tile.bpc ),
      sampleType( tile.sampleType ),
      compressionType( tile.compressionType ),
      quality( tile.quality ),
      timestamp( tile.timestamp ),
      tileNum( tile.tileNum ),
      resolution( tile.resolution ),
      hSequence( tile.hSequence ),
      vSequence( tile.vSequence ),
      capacity( tile.capacity ),
      dataLength( tile.dataLength ),
      memoryManaged( tile.memoryManaged ),
      data( NULL )
  {
 
    if( tile.data && tile.dataLength > 0 ){
      allocate( tile.dataLength );
      memcpy( data, tile.data, tile.dataLength );
      memoryManaged = 1;
    }
 
  }
 
 
 
  RawTile& operator= ( const RawTile& tile ) {
 
    if( this != &tile ){
 
      tileNum = tile.tileNum;
      resolution = tile.resolution;
      hSequence = tile.hSequence;
      vSequence = tile.vSequence;
      compressionType = tile.compressionType;
      quality = tile.quality;
      filename = tile.filename;
      timestamp = tile.timestamp;
      memoryManaged = tile.memoryManaged;
      dataLength = tile.dataLength;
      width = tile.width;
      height = tile.height;
      channels = tile.channels;
      bpc = tile.bpc;
      sampleType = tile.sampleType;
      capacity = tile.capacity;
 
      if( tile.data && tile.dataLength > 0 ){
        allocate( tile.dataLength );
        memcpy( data, tile.data, tile.dataLength );
        memoryManaged = 1;
      }
    }
 
    return *this;
  }
 
 
 
 
  void allocate( uint32_t size = 0 ) {
 
    if( size == 0 ) size = (uint32_t) width * height * channels * (bpc/8);
 
    switch( bpc ){
      case 32:
        if( sampleType == FLOATINGPOINT ) data = new float[size/4];
        else data = new int[size/4];
        break;
      case 16:
        data = new unsigned short[size/2];
        break;
      default:
        data = new unsigned char[size];
        break;
    }
 
    memoryManaged = 1;
    capacity = size;
  };
 
 
 
  void deallocate( void* buffer ) {
 
    if( buffer ){
      switch( bpc ){
        case 32:
          if( sampleType == FLOATINGPOINT ) delete[] (float*) buffer;
          else delete[] (unsigned int*) buffer;
          break;
        case 16:
          delete[] (unsigned short*) buffer;
          break;
        default:
          delete[] (unsigned char*) buffer;
          break;
      }
 
      buffer = NULL;
      capacity = 0;
      dataLength = 0;
    }
  };
 
 
 
 
  void crop( const unsigned int w, const unsigned int h ) {
 
    // Keep track of original data buffer and whether we manage it
    void* buffer = data;
    int mm = memoryManaged;
 
    // Create a new buffer with the new size
    unsigned int len = w * h * channels * (bpc/8);
    allocate( len );
 
    unsigned char* src_ptr = (unsigned char*) buffer;
    unsigned char* dst_ptr = (unsigned char*) data;
 
    // Copy one scanline at a time
    unsigned int dlen = w * channels * (bpc/8);
    unsigned int slen = width * channels * (bpc/8);
 
    for( unsigned int i=0; i<h; i++ ){
      memcpy( dst_ptr, src_ptr, dlen );
      dst_ptr += dlen;
      src_ptr += slen;
    }
 
    // Delete original memory buffer
    if( mm ) deallocate( buffer );
 
    // Set the new tile dimensions and data storage size
    capacity = len;   // Need to set this manually as deallocate sets this to zero
    dataLength = len;
    width = w;
    height = h;
  };
 
 
 
  friend int operator == ( const RawTile& A, const RawTile& B ) {
    if( (A.tileNum == B.tileNum) &&
        (A.resolution == B.resolution) &&
        (A.hSequence == B.hSequence) &&
        (A.vSequence == B.vSequence) &&
        (A.compressionType == B.compressionType) &&
        (A.quality == B.quality) &&
        (A.filename == B.filename) ){
      return 1;
    }
    else return 0;
  }
 
 
 
  friend int operator != ( const RawTile& A, const RawTile& B ) {
    if( (A.tileNum == B.tileNum) &&
        (A.resolution == B.resolution) &&
        (A.hSequence == B.hSequence) &&
        (A.vSequence == B.vSequence) &&
        (A.compressionType == B.compressionType) &&
        (A.quality == B.quality) &&
        (A.filename == B.filename) ){
      return 0;
    }
    else return 1;
  }
 
 
 
  // Memory efficient move operators possible in C++11 onwards
#if (__cplusplus >= 201103L) || ((defined(_MSC_VER) && _MSC_VER >= 1900))
 
  RawTile( RawTile&& tile ) noexcept
    : filename( tile.filename ),
      width( tile.width ),
      height( tile.height ),
      channels( tile.channels ),
      bpc( tile.bpc ),
      sampleType( tile.sampleType ),
      compressionType( tile.compressionType ),
      quality( tile.quality ),
      timestamp( tile.timestamp ),
      tileNum( tile.tileNum ),
      resolution( tile.resolution ),
      hSequence( tile.hSequence ),
      vSequence( tile.vSequence ),
      capacity( tile.capacity ),
      dataLength( tile.dataLength ),
      memoryManaged( tile.memoryManaged ),
      data( NULL )
  {
 
    if( tile.memoryManaged == 1 ){
 
      // Transfer ownership of data
      data = tile.data;
 
      // Free data from other RawTile
      tile.data = nullptr;
      tile.dataLength = 0;
      tile.capacity = 0;
      tile.memoryManaged = 0;
    }
    // Need to copy data if other tile is not owner of its data
    else if( tile.data && tile.dataLength > 0 ){
      allocate( tile.dataLength );
      memcpy( data, tile.data, tile.dataLength );
      memoryManaged = 1;
    }
  }
 
 
 
  RawTile& operator= ( RawTile&& tile ) noexcept {
 
    if( this != &tile ){
 
      if( data && dataLength>0 ) delete this;
 
      // Use move for std::string. The other fields are of basic type
      filename = std::move( tile.filename );
      tileNum = tile.tileNum;
      resolution = tile.resolution;
      hSequence = tile.hSequence;
      vSequence = tile.vSequence;
      compressionType = tile.compressionType;
      quality = tile.quality;
      timestamp = tile.timestamp;
      memoryManaged = tile.memoryManaged;
      capacity = tile.capacity;
      dataLength = tile.dataLength;
      width = tile.width;
      height = tile.height;
      channels = tile.channels;
      bpc = tile.bpc;
      sampleType = tile.sampleType;
 
      if( tile.memoryManaged == 1 ){
 
        // Transfer ownership of raw data
        data = tile.data;
 
        // Free data from other tile
        tile.data = nullptr;
        tile.dataLength = 0;
        tile.capacity = 0;
        tile.memoryManaged = 0;
      }
      else if( tile.data && tile.dataLength > 0 ){
        allocate( tile.dataLength );
        memcpy( data, tile.data, tile.dataLength );
        memoryManaged = 1;
      }
    }
 
    return *this;
  }
 
#endif
 
};
 
#endif