/* * Copyright (c) 2018, Even Rouault * Author: * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #include "tif_lerc.h" #include "Lerc_c_api.h" #include "zlib.h" #ifdef ZSTD_SUPPORT #include "zstd.h" #endif #include #define LSTATE_INIT_DECODE 0x01 #define LSTATE_INIT_ENCODE 0x02 /* * State block for each open TIFF file using LERC compression/decompression. */ typedef struct { double maxzerror; /* max z error */ int lerc_version; int additional_compression; int zstd_compress_level; /* zstd */ int zipquality; /* deflate */ int state; /* state flags */ uint32 segment_width; uint32 segment_height; unsigned int uncompressed_size; unsigned int uncompressed_alloc; uint8 *uncompressed_buffer; unsigned int uncompressed_offset; unsigned int mask_size; uint8 *mask_buffer; unsigned int compressed_size; void *compressed_buffer; TIFFVGetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ } LERCState; #define LState(tif) ((LERCState*) (tif)->tif_data) #define DecoderState(tif) LState(tif) #define EncoderState(tif) LState(tif) static int LERCEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); static int LERCDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); static int LERCFixupTags(TIFF* tif) { (void) tif; return 1; } static int LERCSetupDecode(TIFF* tif) { LERCState* sp = DecoderState(tif); assert(sp != NULL); /* if we were last encoding, terminate this mode */ if (sp->state & LSTATE_INIT_ENCODE) { sp->state = 0; } sp->state |= LSTATE_INIT_DECODE; return 1; } static int GetLercDataType(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; static const char module[] = "GetLercDataType"; if( td->td_sampleformat == SAMPLEFORMAT_INT && td->td_bitspersample == 8 ) { return 0; } if( td->td_sampleformat == SAMPLEFORMAT_UINT && td->td_bitspersample == 8 ) { return 1; } if( td->td_sampleformat == SAMPLEFORMAT_INT && td->td_bitspersample == 16 ) { return 2; } if( td->td_sampleformat == SAMPLEFORMAT_UINT && td->td_bitspersample == 16 ) { return 3; } if( td->td_sampleformat == SAMPLEFORMAT_INT && td->td_bitspersample == 32 ) { return 4; } if( td->td_sampleformat == SAMPLEFORMAT_UINT && td->td_bitspersample == 32 ) { return 5; } if( td->td_sampleformat == SAMPLEFORMAT_IEEEFP && td->td_bitspersample == 32 ) { return 6; } if( td->td_sampleformat == SAMPLEFORMAT_IEEEFP && td->td_bitspersample == 64 ) { return 7; } TIFFErrorExt(tif->tif_clientdata, module, "Unsupported combination of SampleFormat and td_bitspersample"); return -1; } static int SetupUncompressedBuffer(TIFF* tif, LERCState* sp, const char* module) { TIFFDirectory *td = &tif->tif_dir; uint64 new_size_64; uint64 new_alloc_64; unsigned int new_size; unsigned int new_alloc; sp->uncompressed_offset = 0; if (isTiled(tif)) { sp->segment_width = td->td_tilewidth; sp->segment_height = td->td_tilelength; } else { sp->segment_width = td->td_imagewidth; sp->segment_height = td->td_imagelength - tif->tif_row; if (sp->segment_height > td->td_rowsperstrip) sp->segment_height = td->td_rowsperstrip; } new_size_64 = (uint64)sp->segment_width * sp->segment_height * (td->td_bitspersample / 8); if( td->td_planarconfig == PLANARCONFIG_CONTIG ) { new_size_64 *= td->td_samplesperpixel; } new_size = (unsigned int)new_size_64; sp->uncompressed_size = new_size; /* add some margin as we are going to use it also to store deflate/zstd compressed data */ new_alloc_64 = 100 + new_size_64 + new_size_64 / 3; #ifdef ZSTD_SUPPORT { size_t zstd_max = ZSTD_compressBound((size_t)new_size_64); if( new_alloc_64 < zstd_max ) { new_alloc_64 = zstd_max; } } #endif new_alloc = (unsigned int)new_alloc_64; if( new_alloc != new_alloc_64 ) { TIFFErrorExt(tif->tif_clientdata, module, "Too large uncompressed strip/tile"); _TIFFfree(sp->uncompressed_buffer); sp->uncompressed_buffer = 0; sp->uncompressed_alloc = 0; return 0; } if( sp->uncompressed_alloc < new_alloc ) { _TIFFfree(sp->uncompressed_buffer); sp->uncompressed_buffer = _TIFFmalloc(new_alloc); if( !sp->uncompressed_buffer ) { TIFFErrorExt(tif->tif_clientdata, module, "Cannot allocate buffer"); _TIFFfree(sp->uncompressed_buffer); sp->uncompressed_buffer = 0; sp->uncompressed_alloc = 0; return 0; } sp->uncompressed_alloc = new_alloc; } if( td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_extrasamples > 0 && td->td_sampleinfo[td->td_extrasamples-1] == EXTRASAMPLE_UNASSALPHA && GetLercDataType(tif) == 1 ) { unsigned int mask_size = sp->segment_width * sp->segment_height; if( sp->mask_size < mask_size ) { _TIFFfree(sp->mask_buffer); sp->mask_buffer = _TIFFmalloc(mask_size); if( !sp->mask_buffer ) { TIFFErrorExt(tif->tif_clientdata, module, "Cannot allocate buffer"); sp->mask_size = 0; _TIFFfree(sp->uncompressed_buffer); sp->uncompressed_buffer = 0; sp->uncompressed_alloc = 0; return 0; } sp->mask_size = mask_size; } } return 1; } /* * Setup state for decoding a strip. */ static int LERCPreDecode(TIFF* tif, uint16 s) { static const char module[] = "LERCPreDecode"; lerc_status lerc_ret; TIFFDirectory *td = &tif->tif_dir; LERCState* sp = DecoderState(tif); int lerc_data_type; unsigned int infoArray[8]; unsigned nomask_bands = td->td_samplesperpixel; int ndims; int use_mask = 0; uint8* lerc_data = tif->tif_rawcp; unsigned int lerc_data_size = (unsigned int)tif->tif_rawcc; (void) s; assert(sp != NULL); lerc_data_type = GetLercDataType(tif); if( lerc_data_type < 0 ) return 0; if( !SetupUncompressedBuffer(tif, sp, module) ) return 0; if( sp->additional_compression != LERC_ADD_COMPRESSION_NONE ) { if( sp->compressed_size < sp->uncompressed_alloc ) { _TIFFfree(sp->compressed_buffer); sp->compressed_buffer = _TIFFmalloc(sp->uncompressed_alloc); if( !sp->compressed_buffer ) { sp->compressed_size = 0; return 0; } sp->compressed_size = sp->uncompressed_alloc; } } if( sp->additional_compression == LERC_ADD_COMPRESSION_DEFLATE ) { z_stream strm; int zlib_ret; memset(&strm, 0, sizeof(strm)); strm.zalloc = NULL; strm.zfree = NULL; strm.opaque = NULL; zlib_ret = inflateInit(&strm); if( zlib_ret != Z_OK ) { TIFFErrorExt(tif->tif_clientdata, module, "inflateInit() failed"); inflateEnd(&strm); return 0; } strm.avail_in = (uInt)tif->tif_rawcc; strm.next_in = tif->tif_rawcp; strm.avail_out = sp->compressed_size; strm.next_out = sp->compressed_buffer; zlib_ret = inflate(&strm, Z_FINISH); if( zlib_ret != Z_STREAM_END && zlib_ret != Z_OK ) { TIFFErrorExt(tif->tif_clientdata, module, "inflate() failed"); inflateEnd(&strm); return 0; } lerc_data = sp->compressed_buffer; lerc_data_size = sp->compressed_size - strm.avail_out; inflateEnd(&strm); } else if( sp->additional_compression == LERC_ADD_COMPRESSION_ZSTD ) { #ifdef ZSTD_SUPPORT size_t zstd_ret; zstd_ret = ZSTD_decompress(sp->compressed_buffer, sp->compressed_size, tif->tif_rawcp, tif->tif_rawcc); if( ZSTD_isError(zstd_ret) ) { TIFFErrorExt(tif->tif_clientdata, module, "Error in ZSTD_decompress(): %s", ZSTD_getErrorName(zstd_ret)); return 0; } lerc_data = sp->compressed_buffer; lerc_data_size = (unsigned int)zstd_ret; #else TIFFErrorExt(tif->tif_clientdata, module, "ZSTD support missing"); return 0; #endif } else if( sp->additional_compression != LERC_ADD_COMPRESSION_NONE ) { TIFFErrorExt(tif->tif_clientdata, module, "Unhandled additional compression"); return 0; } lerc_ret = lerc_getBlobInfo( lerc_data, lerc_data_size, infoArray, NULL, 8, 0); if( lerc_ret != 0 ) { TIFFErrorExt(tif->tif_clientdata, module, "lerc_getBlobInfo() failed"); return 0; } /* If the configuration is compatible of a LERC mask, and that the */ /* LERC info has dim == samplesperpixel - 1, then there is a LERC */ /* mask. */ if( td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_extrasamples > 0 && td->td_sampleinfo[td->td_extrasamples-1] == EXTRASAMPLE_UNASSALPHA && GetLercDataType(tif) == 1 && infoArray[2] == td->td_samplesperpixel - 1U ) { use_mask = 1; nomask_bands --; } ndims = td->td_planarconfig == PLANARCONFIG_CONTIG ? nomask_bands : 1; /* Info returned in infoArray is { version, dataType, nDim, nCols, nRows, nBands, nValidPixels, blobSize } */ if( infoArray[0] != (unsigned)sp->lerc_version ) { TIFFWarningExt(tif->tif_clientdata, module, "Unexpected version number: %d. Expected: %d", infoArray[0], sp->lerc_version); } if( infoArray[1] != (unsigned)lerc_data_type ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected dataType: %d. Expected: %d", infoArray[1], lerc_data_type); return 0; } if( infoArray[2] != (unsigned)ndims ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected nDim: %d. Expected: %d", infoArray[2], ndims); return 0; } if( infoArray[3] != sp->segment_width ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected nCols: %d. Expected: %du", infoArray[3], sp->segment_width); return 0; } if( infoArray[4] != sp->segment_height ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected nRows: %d. Expected: %u", infoArray[4], sp->segment_height); return 0; } if( infoArray[5] != 1 ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected nBands: %d. Expected: %d", infoArray[5], 1); return 0; } if( infoArray[7] != lerc_data_size ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected blobSize: %d. Expected: %u", infoArray[7], lerc_data_size); return 0; } lerc_ret = lerc_decode( lerc_data, lerc_data_size, use_mask ? sp->mask_buffer : NULL, ndims, sp->segment_width, sp->segment_height, 1, lerc_data_type, sp->uncompressed_buffer); if( lerc_ret != 0 ) { TIFFErrorExt(tif->tif_clientdata, module, "lerc_decode() failed"); return 0; } /* Interleave alpha mask with other samples. */ if( use_mask ) { unsigned src_stride = (td->td_samplesperpixel - 1) * (td->td_bitspersample / 8); unsigned dst_stride = td->td_samplesperpixel * (td->td_bitspersample / 8); unsigned i = sp->segment_width * sp->segment_height; /* Operate from end to begin to be able to move in place */ while( i > 0 && i > nomask_bands ) { i --; sp->uncompressed_buffer[ i * dst_stride + td->td_samplesperpixel - 1] = 255 * sp->mask_buffer[i]; memcpy( sp->uncompressed_buffer + i * dst_stride, sp->uncompressed_buffer + i * src_stride, src_stride ); } /* First pixels must use memmove due to overlapping areas */ while( i > 0 ) { i --; sp->uncompressed_buffer[ i * dst_stride + td->td_samplesperpixel - 1] = 255 * sp->mask_buffer[i]; memmove( sp->uncompressed_buffer + i * dst_stride, sp->uncompressed_buffer + i * src_stride, src_stride ); } } return 1; } /* * Decode a strip, tile or scanline. */ static int LERCDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { static const char module[] = "LERCDecode"; LERCState* sp = DecoderState(tif); (void) s; assert(sp != NULL); assert(sp->state == LSTATE_INIT_DECODE); if( sp->uncompressed_buffer == 0 ) { TIFFErrorExt(tif->tif_clientdata, module, "Uncompressed buffer not allocated"); return 0; } if( (uint64)sp->uncompressed_offset + (uint64)occ > sp->uncompressed_size ) { TIFFErrorExt(tif->tif_clientdata, module, "Too many bytes read"); return 0; } memcpy(op, sp->uncompressed_buffer + sp->uncompressed_offset, occ); sp->uncompressed_offset += (unsigned)occ; return 1; } static int LERCSetupEncode(TIFF* tif) { LERCState* sp = EncoderState(tif); assert(sp != NULL); if (sp->state & LSTATE_INIT_DECODE) { sp->state = 0; } sp->state |= LSTATE_INIT_ENCODE; return 1; } /* * Reset encoding state at the start of a strip. */ static int LERCPreEncode(TIFF* tif, uint16 s) { static const char module[] = "LERCPreEncode"; LERCState *sp = EncoderState(tif); int lerc_data_type; (void) s; assert(sp != NULL); lerc_data_type = GetLercDataType(tif); if( lerc_data_type < 0 ) return 0; if( !SetupUncompressedBuffer(tif, sp, module) ) return 0; return 1; } /* * Encode a chunk of pixels. */ static int LERCEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { static const char module[] = "LERCEncode"; LERCState *sp = EncoderState(tif); (void)s; assert(sp != NULL); assert(sp->state == LSTATE_INIT_ENCODE); if( (uint64)sp->uncompressed_offset + (uint64)cc > sp->uncompressed_size ) { TIFFErrorExt(tif->tif_clientdata, module, "Too many bytes written"); return 0; } memcpy(sp->uncompressed_buffer + sp->uncompressed_offset, bp, cc); sp->uncompressed_offset += (unsigned)cc; return 1; } /* * Finish off an encoded strip by flushing it. */ static int LERCPostEncode(TIFF* tif) { lerc_status lerc_ret; static const char module[] = "LERCPostEncode"; LERCState *sp = EncoderState(tif); unsigned int numBytes = 0; unsigned int numBytesWritten = 0; TIFFDirectory *td = &tif->tif_dir; int use_mask = 0; unsigned dst_nbands = td->td_samplesperpixel; if( sp->uncompressed_offset != sp->uncompressed_size ) { TIFFErrorExt(tif->tif_clientdata, module, "Unexpected number of bytes in the buffer"); return 0; } /* Extract alpha mask (if containing only 0 and 255 values, */ /* and compact array of regular bands */ if( td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_extrasamples > 0 && td->td_sampleinfo[td->td_extrasamples-1] == EXTRASAMPLE_UNASSALPHA && GetLercDataType(tif) == 1 ) { unsigned dst_stride = (td->td_samplesperpixel - 1) * (td->td_bitspersample / 8); unsigned src_stride = td->td_samplesperpixel * (td->td_bitspersample / 8); unsigned i = 0; unsigned nb_pixels = sp->segment_width * sp->segment_height; use_mask = 1; for( i = 0 ; i < nb_pixels; i++) { int v = sp->uncompressed_buffer[ i * src_stride + td->td_samplesperpixel - 1]; if( v != 0 && v != 255 ) { use_mask = 0; break; } } if( use_mask ) { dst_nbands --; /* First pixels must use memmove due to overlapping areas */ for( i = 0 ;i < dst_nbands && i < nb_pixels; i++) { memmove( sp->uncompressed_buffer + i * dst_stride, sp->uncompressed_buffer + i * src_stride, dst_stride ); sp->mask_buffer[i] = sp->uncompressed_buffer[ i * src_stride + td->td_samplesperpixel - 1]; } for(; i < nb_pixels; i++) { memcpy( sp->uncompressed_buffer + i * dst_stride, sp->uncompressed_buffer + i * src_stride, dst_stride ); sp->mask_buffer[i] = sp->uncompressed_buffer[ i * src_stride + td->td_samplesperpixel - 1]; } } } #if 0 lerc_ret = lerc_computeCompressedSize( sp->uncompressed_buffer, sp->lerc_version, GetLercDataType(tif), td->td_planarconfig == PLANARCONFIG_CONTIG ? dst_nbands : 1, sp->segment_width, sp->segment_height, 1, use_mask ? sp->mask_buffer : NULL, sp->maxzerror, &numBytes); if( lerc_ret != 0 ) { TIFFErrorExt(tif->tif_clientdata, module, "lerc_computeCompressedSize() failed"); return 0; } #else numBytes = sp->uncompressed_alloc; #endif if( sp->compressed_size < numBytes ) { _TIFFfree(sp->compressed_buffer); sp->compressed_buffer = _TIFFmalloc(numBytes); if( !sp->compressed_buffer ) { sp->compressed_size = 0; return 0; } sp->compressed_size = numBytes; } lerc_ret = lerc_encodeForVersion( sp->uncompressed_buffer, sp->lerc_version, GetLercDataType(tif), td->td_planarconfig == PLANARCONFIG_CONTIG ? dst_nbands : 1, sp->segment_width, sp->segment_height, 1, use_mask ? sp->mask_buffer : NULL, sp->maxzerror, sp->compressed_buffer, sp->compressed_size, &numBytesWritten); if( lerc_ret != 0 ) { TIFFErrorExt(tif->tif_clientdata, module, "lerc_encode() failed"); return 0; } assert( numBytesWritten < numBytes ); if( sp->additional_compression == LERC_ADD_COMPRESSION_DEFLATE ) { z_stream strm; int zlib_ret; memset(&strm, 0, sizeof(strm)); strm.zalloc = NULL; strm.zfree = NULL; strm.opaque = NULL; zlib_ret = deflateInit(&strm, sp->zipquality); if( zlib_ret != Z_OK ) { TIFFErrorExt(tif->tif_clientdata, module, "deflateInit() failed"); return 0; } strm.avail_in = numBytesWritten; strm.next_in = sp->compressed_buffer; strm.avail_out = sp->uncompressed_alloc; strm.next_out = sp->uncompressed_buffer; zlib_ret = deflate(&strm, Z_FINISH); if( zlib_ret != Z_STREAM_END ) { TIFFErrorExt(tif->tif_clientdata, module, "deflate() failed"); deflateEnd(&strm); return 0; } { int ret; uint8* tif_rawdata_backup = tif->tif_rawdata; tif->tif_rawdata = sp->uncompressed_buffer; tif->tif_rawcc = sp->uncompressed_alloc - strm.avail_out; ret = TIFFFlushData1(tif); tif->tif_rawdata = tif_rawdata_backup; if( !ret ) { deflateEnd(&strm); return 0; } } deflateEnd(&strm); } else if( sp->additional_compression == LERC_ADD_COMPRESSION_ZSTD ) { #ifdef ZSTD_SUPPORT size_t zstd_ret = ZSTD_compress( sp->uncompressed_buffer, sp->uncompressed_alloc, sp->compressed_buffer, numBytesWritten, sp->zstd_compress_level ); if( ZSTD_isError(zstd_ret) ) { TIFFErrorExt(tif->tif_clientdata, module, "Error in ZSTD_compress(): %s", ZSTD_getErrorName(zstd_ret)); return 0; } { int ret; uint8* tif_rawdata_backup = tif->tif_rawdata; tif->tif_rawdata = sp->uncompressed_buffer; tif->tif_rawcc = zstd_ret; ret = TIFFFlushData1(tif); tif->tif_rawdata = tif_rawdata_backup; if( !ret ) { return 0; } } #else TIFFErrorExt(tif->tif_clientdata, module, "ZSTD support missing"); return 0; #endif } else if( sp->additional_compression != LERC_ADD_COMPRESSION_NONE ) { TIFFErrorExt(tif->tif_clientdata, module, "Unhandled additional compression"); return 0; } else { int ret; uint8* tif_rawdata_backup = tif->tif_rawdata; tif->tif_rawdata = sp->compressed_buffer; tif->tif_rawcc = numBytesWritten; ret = TIFFFlushData1(tif); tif->tif_rawdata = tif_rawdata_backup; if( !ret ) return 0; } return 1; } static void LERCCleanup(TIFF* tif) { LERCState* sp = LState(tif); assert(sp != 0); tif->tif_tagmethods.vgetfield = sp->vgetparent; tif->tif_tagmethods.vsetfield = sp->vsetparent; _TIFFfree(sp->uncompressed_buffer); _TIFFfree(sp->compressed_buffer); _TIFFfree(sp->mask_buffer); _TIFFfree(sp); tif->tif_data = NULL; _TIFFSetDefaultCompressionState(tif); } static const TIFFField LERCFields[] = { { TIFFTAG_LERC_PARAMETERS, TIFF_VARIABLE2, TIFF_VARIABLE2, TIFF_LONG, 0, TIFF_SETGET_C32_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, FALSE, TRUE, "LercParameters", NULL }, { TIFFTAG_LERC_MAXZERROR, 0, 0, TIFF_ANY, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "LercMaximumError", NULL }, { TIFFTAG_LERC_VERSION, 0, 0, TIFF_ANY, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "LercVersion", NULL }, { TIFFTAG_LERC_ADD_COMPRESSION, 0, 0, TIFF_ANY, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "LercAdditionalCompression", NULL }, { TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "ZSTD zstd_compress_level", NULL }, { TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL }, }; static int LERCVSetFieldBase(TIFF* tif, uint32 tag, ...) { LERCState* sp = LState(tif); int ret; va_list ap; va_start(ap, tag); ret = (*sp->vsetparent)(tif, tag, ap); va_end(ap); return ret; } static int LERCVSetField(TIFF* tif, uint32 tag, va_list ap) { static const char module[] = "LERCVSetField"; LERCState* sp = LState(tif); switch (tag) { case TIFFTAG_LERC_PARAMETERS: { uint32 count = va_arg(ap, int); int* params = va_arg(ap, int*); if( count < 2 ) { TIFFErrorExt(tif->tif_clientdata, module, "Invalid count for LercParameters: %u", count); return 0; } sp->lerc_version = params[0]; sp->additional_compression = params[1]; return LERCVSetFieldBase(tif, TIFFTAG_LERC_PARAMETERS, count, params); } case TIFFTAG_LERC_MAXZERROR: sp->maxzerror = va_arg(ap, double); return 1; case TIFFTAG_LERC_VERSION: { int params[2] = {0, 0}; int version = va_arg(ap, int); if( version != LERC_VERSION_2_4 ) { TIFFErrorExt(tif->tif_clientdata, module, "Invalid value for LercVersion: %d", version); return 0; } sp->lerc_version = version; params[0] = sp->lerc_version; params[1] = sp->additional_compression; return LERCVSetFieldBase(tif, TIFFTAG_LERC_PARAMETERS, 2, params); } case TIFFTAG_LERC_ADD_COMPRESSION: { int params[2] = {0, 0}; int additional_compression = va_arg(ap, int); #ifndef ZSTD_SUPPORT if( additional_compression == LERC_ADD_COMPRESSION_ZSTD ) { TIFFErrorExt(tif->tif_clientdata, module, "LERC_ZSTD requested, but ZSTD not available"); return 0; } #endif if( additional_compression != LERC_ADD_COMPRESSION_NONE && additional_compression != LERC_ADD_COMPRESSION_DEFLATE && additional_compression != LERC_ADD_COMPRESSION_ZSTD ) { TIFFErrorExt(tif->tif_clientdata, module, "Invalid value for LercAdditionalCompression: %d", additional_compression); return 0; } sp->additional_compression = additional_compression; params[0] = sp->lerc_version; params[1] = sp->additional_compression; return LERCVSetFieldBase(tif, TIFFTAG_LERC_PARAMETERS, 2, params); } #ifdef ZSTD_SUPPORT case TIFFTAG_ZSTD_LEVEL: { sp->zstd_compress_level = (int) va_arg(ap, int); if( sp->zstd_compress_level <= 0 || sp->zstd_compress_level > ZSTD_maxCLevel() ) { TIFFWarningExt(tif->tif_clientdata, module, "ZSTD_LEVEL should be between 1 and %d", ZSTD_maxCLevel()); } return 1; } #endif case TIFFTAG_ZIPQUALITY: { sp->zipquality = (int) va_arg(ap, int); return (1); } default: return (*sp->vsetparent)(tif, tag, ap); } /*NOTREACHED*/ } static int LERCVGetField(TIFF* tif, uint32 tag, va_list ap) { LERCState* sp = LState(tif); switch (tag) { case TIFFTAG_LERC_MAXZERROR: *va_arg(ap, double*) = sp->maxzerror; break; case TIFFTAG_LERC_VERSION: *va_arg(ap, int*) = sp->lerc_version; break; case TIFFTAG_LERC_ADD_COMPRESSION: *va_arg(ap, int*) = sp->additional_compression; break; case TIFFTAG_ZSTD_LEVEL: *va_arg(ap, int*) = sp->zstd_compress_level; break; case TIFFTAG_ZIPQUALITY: *va_arg(ap, int*) = sp->zipquality; break; default: return (*sp->vgetparent)(tif, tag, ap); } return 1; } int TIFFInitLERC(TIFF* tif, int scheme) { static const char module[] = "TIFFInitLERC"; LERCState* sp; assert( scheme == COMPRESSION_LERC ); /* * Merge codec-specific tag information. */ if (!_TIFFMergeFields(tif, LERCFields, TIFFArrayCount(LERCFields))) { TIFFErrorExt(tif->tif_clientdata, module, "Merging LERC codec-specific tags failed"); return 0; } /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (uint8*) _TIFFcalloc(1, sizeof(LERCState)); if (tif->tif_data == NULL) goto bad; sp = LState(tif); /* * Override parent get/set field methods. */ sp->vgetparent = tif->tif_tagmethods.vgetfield; tif->tif_tagmethods.vgetfield = LERCVGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_tagmethods.vsetfield; tif->tif_tagmethods.vsetfield = LERCVSetField; /* hook for codec tags */ /* * Install codec methods. */ tif->tif_fixuptags = LERCFixupTags; tif->tif_setupdecode = LERCSetupDecode; tif->tif_predecode = LERCPreDecode; tif->tif_decoderow = LERCDecode; tif->tif_decodestrip = LERCDecode; tif->tif_decodetile = LERCDecode; tif->tif_setupencode = LERCSetupEncode; tif->tif_preencode = LERCPreEncode; tif->tif_postencode = LERCPostEncode; tif->tif_encoderow = LERCEncode; tif->tif_encodestrip = LERCEncode; tif->tif_encodetile = LERCEncode; tif->tif_cleanup = LERCCleanup; /* Default values for codec-specific fields */ TIFFSetField(tif, TIFFTAG_LERC_VERSION, LERC_VERSION_2_4); TIFFSetField(tif, TIFFTAG_LERC_ADD_COMPRESSION, LERC_ADD_COMPRESSION_NONE); sp->maxzerror = 0.0; sp->zstd_compress_level = 9; /* default comp. level */ sp->zipquality = Z_DEFAULT_COMPRESSION; /* default comp. level */ sp->state = 0; return 1; bad: TIFFErrorExt(tif->tif_clientdata, module, "No space for LERC state block"); return 0; }