vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b
This commit is contained in:
Gitea Mirror Bot
Vendored
+437
@@ -0,0 +1,437 @@
|
||||
/*
|
||||
* 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 GetZSTDState(tif) ((ZSTDState *)(tif)->tif_data)
|
||||
#define ZSTDDecoderState(tif) GetZSTDState(tif)
|
||||
#define ZSTDEncoderState(tif) GetZSTDState(tif)
|
||||
|
||||
static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
|
||||
static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
|
||||
|
||||
static int ZSTDFixupTags(TIFF *tif)
|
||||
{
|
||||
(void)tif;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ZSTDSetupDecode(TIFF *tif)
|
||||
{
|
||||
ZSTDState *sp = ZSTDDecoderState(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_t s)
|
||||
{
|
||||
static const char module[] = "ZSTDPreDecode";
|
||||
ZSTDState *sp = ZSTDDecoderState(tif);
|
||||
size_t zstd_ret;
|
||||
|
||||
(void)s;
|
||||
assert(sp != NULL);
|
||||
|
||||
if ((sp->state & LSTATE_INIT_DECODE) == 0)
|
||||
tif->tif_setupdecode(tif);
|
||||
|
||||
if (sp->dstream == NULL)
|
||||
{
|
||||
sp->dstream = ZSTD_createDStream();
|
||||
if (sp->dstream == NULL)
|
||||
{
|
||||
TIFFErrorExtR(tif, module, "Cannot allocate decompression stream");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
zstd_ret = ZSTD_initDStream(sp->dstream);
|
||||
if (ZSTD_isError(zstd_ret))
|
||||
{
|
||||
TIFFErrorExtR(tif, module, "Error in ZSTD_initDStream(): %s",
|
||||
ZSTD_getErrorName(zstd_ret));
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
|
||||
{
|
||||
static const char module[] = "ZSTDDecode";
|
||||
ZSTDState *sp = ZSTDDecoderState(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))
|
||||
{
|
||||
memset(op + out_buffer.pos, 0, out_buffer.size - out_buffer.pos);
|
||||
TIFFErrorExtR(tif, 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)
|
||||
{
|
||||
memset(op + out_buffer.pos, 0, out_buffer.size - out_buffer.pos);
|
||||
TIFFErrorExtR(tif, 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 = ZSTDEncoderState(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_t s)
|
||||
{
|
||||
static const char module[] = "ZSTDPreEncode";
|
||||
ZSTDState *sp = ZSTDEncoderState(tif);
|
||||
size_t zstd_ret;
|
||||
|
||||
(void)s;
|
||||
assert(sp != NULL);
|
||||
if (sp->state != LSTATE_INIT_ENCODE)
|
||||
tif->tif_setupencode(tif);
|
||||
|
||||
if (sp->cstream == NULL)
|
||||
{
|
||||
sp->cstream = ZSTD_createCStream();
|
||||
if (sp->cstream == NULL)
|
||||
{
|
||||
TIFFErrorExtR(tif, module, "Cannot allocate compression stream");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
|
||||
if (ZSTD_isError(zstd_ret))
|
||||
{
|
||||
TIFFErrorExtR(tif, 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_t *bp, tmsize_t cc, uint16_t s)
|
||||
{
|
||||
static const char module[] = "ZSTDEncode";
|
||||
ZSTDState *sp = ZSTDEncoderState(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))
|
||||
{
|
||||
TIFFErrorExtR(tif, 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 = ZSTDEncoderState(tif);
|
||||
size_t zstd_ret;
|
||||
|
||||
do
|
||||
{
|
||||
zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
|
||||
if (ZSTD_isError(zstd_ret))
|
||||
{
|
||||
TIFFErrorExtR(tif, 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 = GetZSTDState(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;
|
||||
}
|
||||
_TIFFfreeExt(tif, sp);
|
||||
tif->tif_data = NULL;
|
||||
|
||||
_TIFFSetDefaultCompressionState(tif);
|
||||
}
|
||||
|
||||
static int ZSTDVSetField(TIFF *tif, uint32_t tag, va_list ap)
|
||||
{
|
||||
static const char module[] = "ZSTDVSetField";
|
||||
ZSTDState *sp = GetZSTDState(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())
|
||||
{
|
||||
TIFFWarningExtR(tif, 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_t tag, va_list ap)
|
||||
{
|
||||
ZSTDState *sp = GetZSTDState(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, FIELD_PSEUDO, TRUE,
|
||||
FALSE, "ZSTD compression_level", NULL},
|
||||
};
|
||||
|
||||
int TIFFInitZSTD(TIFF *tif, int scheme)
|
||||
{
|
||||
static const char module[] = "TIFFInitZSTD";
|
||||
ZSTDState *sp;
|
||||
|
||||
(void)scheme;
|
||||
assert(scheme == COMPRESSION_ZSTD);
|
||||
|
||||
/*
|
||||
* Merge codec-specific tag information.
|
||||
*/
|
||||
if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields)))
|
||||
{
|
||||
TIFFErrorExtR(tif, module, "Merging ZSTD codec-specific tags failed");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate state block so tag methods have storage to record values.
|
||||
*/
|
||||
tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(ZSTDState));
|
||||
if (tif->tif_data == NULL)
|
||||
goto bad;
|
||||
sp = GetZSTDState(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:
|
||||
TIFFErrorExtR(tif, module, "No space for ZSTD state block");
|
||||
return 0;
|
||||
}
|
||||
#endif /* ZSTD_SUPPORT */
|
||||
Reference in New Issue
Block a user