mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-24 11:10:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
ccfc34b13f
opencv/3rdparty/libtiff/tif_zstd.c

443 lines
13 KiB
C
Raw Blame History

/*
* Copyright (c) 2017, Planet Labs
* Author: <even.rouault at spatialys.com>
*
* 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"
#ifdef ZSTD_SUPPORT
/*
* TIFF Library.
*
* ZSTD Compression Support
*
*/
#include "tif_predict.h"
#include "zstd.h"
#include <stdio.h>
/*
* State block for each open TIFF file using ZSTD compression/decompression.
*/
typedef struct {
TIFFPredictorState predict;
ZSTD_DStream* dstream;
ZSTD_CStream* cstream;
int compression_level; /* compression level */
ZSTD_outBuffer out_buffer;
int state; /* state flags */
#define LSTATE_INIT_DECODE 0x01
#define LSTATE_INIT_ENCODE 0x02
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
} ZSTDState;
#define LState(tif) ((ZSTDState*) (tif)->tif_data)
#define DecoderState(tif) LState(tif)
#define EncoderState(tif) LState(tif)
static int ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
static int ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
static int
ZSTDFixupTags(TIFF* tif)
{
(void) tif;
return 1;
}
static int
ZSTDSetupDecode(TIFF* tif)
{
ZSTDState* sp = DecoderState(tif);
assert(sp != NULL);
/* if we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) {
ZSTD_freeCStream(sp->cstream);
sp->cstream = NULL;
sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE;
return 1;
}
/*
* Setup state for decoding a strip.
*/
static int
ZSTDPreDecode(TIFF* tif, uint16 s)
{
static const char module[] = "ZSTDPreDecode";
ZSTDState* sp = DecoderState(tif);
size_t zstd_ret;
(void) s;
assert(sp != NULL);
if( (sp->state & LSTATE_INIT_DECODE) == 0 )
tif->tif_setupdecode(tif);
if( sp->dstream )
{
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
}
sp->dstream = ZSTD_createDStream();
if( sp->dstream == NULL ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Cannot allocate decompression stream");
return 0;
}
zstd_ret = ZSTD_initDStream(sp->dstream);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_initDStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
return 1;
}
static int
ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "ZSTDDecode";
ZSTDState* sp = DecoderState(tif);
ZSTD_inBuffer in_buffer;
ZSTD_outBuffer out_buffer;
size_t zstd_ret;
(void) s;
assert(sp != NULL);
assert(sp->state == LSTATE_INIT_DECODE);
in_buffer.src = tif->tif_rawcp;
in_buffer.size = (size_t) tif->tif_rawcc;
in_buffer.pos = 0;
out_buffer.dst = op;
out_buffer.size = (size_t) occ;
out_buffer.pos = 0;
do {
zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer,
&in_buffer);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_decompressStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
} while( zstd_ret != 0 &&
in_buffer.pos < in_buffer.size &&
out_buffer.pos < out_buffer.size );
if (out_buffer.pos < (size_t)occ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %lu (short %lu bytes)",
(unsigned long) tif->tif_row,
(unsigned long) (size_t)occ - out_buffer.pos);
return 0;
}
tif->tif_rawcp += in_buffer.pos;
tif->tif_rawcc -= in_buffer.pos;
return 1;
}
static int
ZSTDSetupEncode(TIFF* tif)
{
ZSTDState* sp = EncoderState(tif);
assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) {
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE;
return 1;
}
/*
* Reset encoding state at the start of a strip.
*/
static int
ZSTDPreEncode(TIFF* tif, uint16 s)
{
static const char module[] = "ZSTDPreEncode";
ZSTDState *sp = EncoderState(tif);
size_t zstd_ret;
(void) s;
assert(sp != NULL);
if( sp->state != LSTATE_INIT_ENCODE )
tif->tif_setupencode(tif);
if (sp->cstream) {
ZSTD_freeCStream(sp->cstream);
sp->cstream = NULL;
}
sp->cstream = ZSTD_createCStream();
if( sp->cstream == NULL ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Cannot allocate compression stream");
return 0;
}
zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_initCStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
sp->out_buffer.dst = tif->tif_rawdata;
sp->out_buffer.size = (size_t)tif->tif_rawdatasize;
sp->out_buffer.pos = 0;
return 1;
}
/*
* Encode a chunk of pixels.
*/
static int
ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
static const char module[] = "ZSTDEncode";
ZSTDState *sp = EncoderState(tif);
ZSTD_inBuffer in_buffer;
size_t zstd_ret;
assert(sp != NULL);
assert(sp->state == LSTATE_INIT_ENCODE);
(void) s;
in_buffer.src = bp;
in_buffer.size = (size_t)cc;
in_buffer.pos = 0;
do {
zstd_ret = ZSTD_compressStream(sp->cstream, &sp->out_buffer,
&in_buffer);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_compressStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
if( sp->out_buffer.pos == sp->out_buffer.size ) {
tif->tif_rawcc = tif->tif_rawdatasize;
if (!TIFFFlushData1(tif))
return 0;
sp->out_buffer.dst = tif->tif_rawcp;
sp->out_buffer.pos = 0;
}
} while( in_buffer.pos < in_buffer.size );
return 1;
}
/*
* Finish off an encoded strip by flushing it.
*/
static int
ZSTDPostEncode(TIFF* tif)
{
static const char module[] = "ZSTDPostEncode";
ZSTDState *sp = EncoderState(tif);
size_t zstd_ret;
do {
zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_endStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
if( sp->out_buffer.pos > 0 ) {
tif->tif_rawcc = sp->out_buffer.pos;
if (!TIFFFlushData1(tif))
return 0;
sp->out_buffer.dst = tif->tif_rawcp;
sp->out_buffer.pos = 0;
}
} while (zstd_ret != 0);
return 1;
}
static void
ZSTDCleanup(TIFF* tif)
{
ZSTDState* sp = LState(tif);
assert(sp != 0);
(void)TIFFPredictorCleanup(tif);
tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent;
if (sp->dstream) {
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
}
if (sp->cstream) {
ZSTD_freeCStream(sp->cstream);
sp->cstream = NULL;
}
_TIFFfree(sp);
tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif);
}
static int
ZSTDVSetField(TIFF* tif, uint32 tag, va_list ap)
{
static const char module[] = "ZSTDVSetField";
ZSTDState* sp = LState(tif);
switch (tag) {
case TIFFTAG_ZSTD_LEVEL:
sp->compression_level = (int) va_arg(ap, int);
if( sp->compression_level <= 0 ||
sp->compression_level > ZSTD_maxCLevel() )
{
TIFFWarningExt(tif->tif_clientdata, module,
"ZSTD_LEVEL should be between 1 and %d",
ZSTD_maxCLevel());
}
return 1;
default:
return (*sp->vsetparent)(tif, tag, ap);
}
/*NOTREACHED*/
}
static int
ZSTDVGetField(TIFF* tif, uint32 tag, va_list ap)
{
ZSTDState* sp = LState(tif);
switch (tag) {
case TIFFTAG_ZSTD_LEVEL:
*va_arg(ap, int*) = sp->compression_level;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
return 1;
}
static const TIFFField ZSTDFields[] = {
{ TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED,
FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level", NULL },
};
int
TIFFInitZSTD(TIFF* tif, int scheme)
{
static const char module[] = "TIFFInitZSTD";
ZSTDState* sp;
assert( scheme == COMPRESSION_ZSTD );
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging ZSTD codec-specific tags failed");
return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (uint8*) _TIFFmalloc(sizeof(ZSTDState));
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 = ZSTDVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = ZSTDVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->compression_level = 9; /* default comp. level */
sp->state = 0;
sp->dstream = 0;
sp->cstream = 0;
sp->out_buffer.dst = NULL;
sp->out_buffer.size = 0;
sp->out_buffer.pos = 0;
/*
* Install codec methods.
*/
tif->tif_fixuptags = ZSTDFixupTags;
tif->tif_setupdecode = ZSTDSetupDecode;
tif->tif_predecode = ZSTDPreDecode;
tif->tif_decoderow = ZSTDDecode;
tif->tif_decodestrip = ZSTDDecode;
tif->tif_decodetile = ZSTDDecode;
tif->tif_setupencode = ZSTDSetupEncode;
tif->tif_preencode = ZSTDPreEncode;
tif->tif_postencode = ZSTDPostEncode;
tif->tif_encoderow = ZSTDEncode;
tif->tif_encodestrip = ZSTDEncode;
tif->tif_encodetile = ZSTDEncode;
tif->tif_cleanup = ZSTDCleanup;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
return 1;
bad:
TIFFErrorExt(tif->tif_clientdata, module,
"No space for ZSTD state block");
return 0;
}
#endif /* ZSTD_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
Reference in New Issue View Git Blame Copy Permalink