Open Source Computer Vision Library https://opencv.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

311 lines
8.5 KiB

/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* 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.
*/
/*
* TIFF Library
*
* Compression Scheme Configuration Support.
*/
#include "tiffiop.h"
static int TIFFNoEncode(TIFF *tif, const char *method)
{
const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c)
{
TIFFErrorExtR(tif, tif->tif_name, "%s %s encoding is not implemented",
c->name, method);
}
else
{
TIFFErrorExtR(tif, tif->tif_name,
"Compression scheme %" PRIu16
" %s encoding is not implemented",
tif->tif_dir.td_compression, method);
}
return (-1);
}
int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "scanline"));
}
int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "strip"));
}
int _TIFFNoTileEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "tile"));
}
static int TIFFNoDecode(TIFF *tif, const char *method)
{
const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c)
TIFFErrorExtR(tif, tif->tif_name, "%s %s decoding is not implemented",
c->name, method);
else
TIFFErrorExtR(tif, tif->tif_name,
"Compression scheme %" PRIu16
" %s decoding is not implemented",
tif->tif_dir.td_compression, method);
return (0);
}
static int _TIFFNoFixupTags(TIFF *tif)
{
(void)tif;
return (1);
}
int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "scanline"));
}
int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "strip"));
}
int _TIFFNoTileDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
{
(void)pp;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "tile"));
}
int _TIFFNoSeek(TIFF *tif, uint32_t off)
{
(void)off;
TIFFErrorExtR(tif, tif->tif_name,
"Compression algorithm does not support random access");
return (0);
}
int _TIFFNoPreCode(TIFF *tif, uint16_t s)
{
(void)tif;
(void)s;
return (1);
}
static int _TIFFtrue(TIFF *tif)
{
(void)tif;
return (1);
}
static void _TIFFvoid(TIFF *tif) { (void)tif; }
void _TIFFSetDefaultCompressionState(TIFF *tif)
{
tif->tif_fixuptags = _TIFFNoFixupTags;
tif->tif_decodestatus = TRUE;
tif->tif_setupdecode = _TIFFtrue;
tif->tif_predecode = _TIFFNoPreCode;
tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_decodestrip = _TIFFNoStripDecode;
tif->tif_decodetile = _TIFFNoTileDecode;
tif->tif_encodestatus = TRUE;
tif->tif_setupencode = _TIFFtrue;
tif->tif_preencode = _TIFFNoPreCode;
tif->tif_postencode = _TIFFtrue;
tif->tif_encoderow = _TIFFNoRowEncode;
tif->tif_encodestrip = _TIFFNoStripEncode;
tif->tif_encodetile = _TIFFNoTileEncode;
tif->tif_close = _TIFFvoid;
tif->tif_seek = _TIFFNoSeek;
tif->tif_cleanup = _TIFFvoid;
tif->tif_defstripsize = _TIFFDefaultStripSize;
tif->tif_deftilesize = _TIFFDefaultTileSize;
tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW);
}
int TIFFSetCompressionScheme(TIFF *tif, int scheme)
{
const TIFFCodec *c = TIFFFindCODEC((uint16_t)scheme);
_TIFFSetDefaultCompressionState(tif);
/*
* Don't treat an unknown compression scheme as an error.
* This permits applications to open files with data that
* the library does not have builtin support for, but which
* may still be meaningful.
*/
return (c ? (*c->init)(tif, scheme) : 1);
}
/*
* Other compression schemes may be registered. Registered
* schemes can also override the builtin versions provided
* by this library.
*/
typedef struct _codec
{
struct _codec *next;
TIFFCodec *info;
} codec_t;
static codec_t *registeredCODECS = NULL;
const TIFFCodec *TIFFFindCODEC(uint16_t scheme)
{
const TIFFCodec *c;
codec_t *cd;
for (cd = registeredCODECS; cd; cd = cd->next)
if (cd->info->scheme == scheme)
return ((const TIFFCodec *)cd->info);
for (c = _TIFFBuiltinCODECS; c->name; c++)
if (c->scheme == scheme)
return (c);
return ((const TIFFCodec *)0);
}
TIFFCodec *TIFFRegisterCODEC(uint16_t scheme, const char *name,
TIFFInitMethod init)
{
codec_t *cd = (codec_t *)_TIFFmallocExt(
NULL,
(tmsize_t)(sizeof(codec_t) + sizeof(TIFFCodec) + strlen(name) + 1));
if (cd != NULL)
{
cd->info = (TIFFCodec *)((uint8_t *)cd + sizeof(codec_t));
cd->info->name = (char *)((uint8_t *)cd->info + sizeof(TIFFCodec));
strcpy(cd->info->name, name);
cd->info->scheme = scheme;
cd->info->init = init;
cd->next = registeredCODECS;
registeredCODECS = cd;
}
else
{
TIFFErrorExt(0, "TIFFRegisterCODEC",
"No space to register compression scheme %s", name);
return NULL;
}
return (cd->info);
}
void TIFFUnRegisterCODEC(TIFFCodec *c)
{
codec_t *cd;
codec_t **pcd;
for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next)
if (cd->info == c)
{
*pcd = cd->next;
_TIFFfreeExt(NULL, cd);
return;
}
TIFFErrorExt(0, "TIFFUnRegisterCODEC",
"Cannot remove compression scheme %s; not registered",
c->name);
}
/************************************************************************/
/* TIFFGetConfisuredCODECs() */
/************************************************************************/
/**
* Get list of configured codecs, both built-in and registered by user.
* Caller is responsible to free this structure.
*
* @return returns array of TIFFCodec records (the last record should be NULL)
* or NULL if function failed.
*/
TIFFCodec *TIFFGetConfiguredCODECs()
{
int i = 1;
codec_t *cd;
const TIFFCodec *c;
TIFFCodec *codecs = NULL;
TIFFCodec *new_codecs;
for (cd = registeredCODECS; cd; cd = cd->next)
{
new_codecs =
(TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec));
i++;
}
for (c = _TIFFBuiltinCODECS; c->name; c++)
{
if (TIFFIsCODECConfigured(c->scheme))
{
new_codecs = (TIFFCodec *)_TIFFreallocExt(NULL, codecs,
i * sizeof(TIFFCodec));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, (const void *)c, sizeof(TIFFCodec));
i++;
}
}
new_codecs =
(TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
return codecs;
}