src/tiff/libtiff/tif_compress.c

/* $Id$ */

/*
 * 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) {
			TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s encoding is not implemented",
                          c->name, method);
	} else {
		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
			  "Compression scheme %u %s encoding is not implemented",
		    tif->tif_dir.td_compression, method);
	}
	return (-1);
}

int
_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
	(void) pp; (void) cc; (void) s;
	return (TIFFNoEncode(tif, "scanline"));
}

int
_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
	(void) pp; (void) cc; (void) s;
	return (TIFFNoEncode(tif, "strip"));
}

int
_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_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)
		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s decoding is not implemented",
		    c->name, method);
	else
		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
		    "Compression scheme %u %s decoding is not implemented",
		    tif->tif_dir.td_compression, method);
	return (-1);
}

int
_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
	(void) pp; (void) cc; (void) s;
	return (TIFFNoDecode(tif, "scanline"));
}

int
_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
	(void) pp; (void) cc; (void) s;
	return (TIFFNoDecode(tif, "strip"));
}

int
_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
	(void) pp; (void) cc; (void) s;
	return (TIFFNoDecode(tif, "tile"));
}

int
_TIFFNoSeek(TIFF* tif, uint32 off)
{
	(void) off;
	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
	    "Compression algorithm does not support random access");
	return (0);
}

int
_TIFFNoPreCode(TIFF* tif, tsample_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_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;
}

int
TIFFSetCompressionScheme(TIFF* tif, int scheme)
{
	const TIFFCodec *c = TIFFFindCODEC((uint16) 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 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 scheme, const char* name, TIFFInitMethod init)
{
	codec_t* cd = (codec_t*)
	    _TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1);

	if (cd != NULL) {
		cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t));
		cd->info->name = (char*)
		    ((tidata_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); pcd = &cd->next)
		if (cd->info == c) {
			*pcd = cd->next;
			_TIFFfree(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, *new_codecs;

        for (cd = registeredCODECS; cd; cd = cd->next) {
                new_codecs = (TIFFCodec *)
			_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
		if (!new_codecs) {
			_TIFFfree (codecs);
			return NULL;
		}
		codecs = new_codecs;
		_TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
		i++;
	}
        for (c = _TIFFBuiltinCODECS; c->name; c++) {
                if (TIFFIsCODECConfigured(c->scheme)) {
                        new_codecs = (TIFFCodec *)
				_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
			if (!new_codecs) {
				_TIFFfree (codecs);
				return NULL;
			}
			codecs = new_codecs;
			_TIFFmemcpy(codecs + i - 1, (const tdata_t)c, sizeof(TIFFCodec));
			i++;
		}
	}

	new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
	if (!new_codecs) {
		_TIFFfree (codecs);
		return NULL;
	}
	codecs = new_codecs;
	_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));

        return codecs;
}

/* vim: set ts=8 sts=8 sw=8 noet: */
Commit	Line	Data
	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	*
	7	* Permission to use, copy, modify, distribute, and sell this software and
	8	* its documentation for any purpose is hereby granted without fee, provided
	9	* that (i) the above copyright notices and this permission notice appear in
	10	* all copies of the software and related documentation, and (ii) the names of
	11	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	12	* publicity relating to the software without the specific, prior written
	13	* permission of Sam Leffler and Silicon Graphics.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	16	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	17	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	18	*
	19	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	20	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	21	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	/*
	28	* TIFF Library
	29	*
	30	* Compression Scheme Configuration Support.
	31	*/
	32	#include "tiffiop.h"
	33
	34	static int
	35	TIFFNoEncode(TIFF* tif, const char* method)
	36	{
	37	const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
	38
	39	if (c) {
	40	TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s encoding is not implemented",
	41	c->name, method);
	42	} else {
	43	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
	44	"Compression scheme %u %s encoding is not implemented",
	45	tif->tif_dir.td_compression, method);
	46	}
	47	return (-1);
	48	}
	49
	50	int
	51	_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	52	{
	53	(void) pp; (void) cc; (void) s;
	54	return (TIFFNoEncode(tif, "scanline"));
	55	}
	56
	57	int
	58	_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	59	{
	60	(void) pp; (void) cc; (void) s;
	61	return (TIFFNoEncode(tif, "strip"));
	62	}
	63
	64	int
	65	_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	66	{
	67	(void) pp; (void) cc; (void) s;
	68	return (TIFFNoEncode(tif, "tile"));
	69	}
	70
	71	static int
	72	TIFFNoDecode(TIFF* tif, const char* method)
	73	{
	74	const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
	75
	76	if (c)
	77	TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s decoding is not implemented",
	78	c->name, method);
	79	else
	80	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
	81	"Compression scheme %u %s decoding is not implemented",
	82	tif->tif_dir.td_compression, method);
	83	return (-1);
	84	}
	85
	86	int
	87	_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	88	{
	89	(void) pp; (void) cc; (void) s;
	90	return (TIFFNoDecode(tif, "scanline"));
	91	}
	92
	93	int
	94	_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	95	{
	96	(void) pp; (void) cc; (void) s;
	97	return (TIFFNoDecode(tif, "strip"));
	98	}
	99
	100	int
	101	_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
	102	{
	103	(void) pp; (void) cc; (void) s;
	104	return (TIFFNoDecode(tif, "tile"));
	105	}
	106
	107	int
	108	_TIFFNoSeek(TIFF* tif, uint32 off)
	109	{
	110	(void) off;
	111	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
	112	"Compression algorithm does not support random access");
	113	return (0);
	114	}
	115
	116	int
	117	_TIFFNoPreCode(TIFF* tif, tsample_t s)
	118	{
	119	(void) tif; (void) s;
	120	return (1);
	121	}
	122
	123	static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); }
	124	static void _TIFFvoid(TIFF* tif) { (void) tif; }
	125
	126	void
	127	_TIFFSetDefaultCompressionState(TIFF* tif)
	128	{
	129	tif->tif_decodestatus = TRUE;
	130	tif->tif_setupdecode = _TIFFtrue;
	131	tif->tif_predecode = _TIFFNoPreCode;
	132	tif->tif_decoderow = _TIFFNoRowDecode;
	133	tif->tif_decodestrip = _TIFFNoStripDecode;
	134	tif->tif_decodetile = _TIFFNoTileDecode;
	135	tif->tif_encodestatus = TRUE;
	136	tif->tif_setupencode = _TIFFtrue;
	137	tif->tif_preencode = _TIFFNoPreCode;
	138	tif->tif_postencode = _TIFFtrue;
	139	tif->tif_encoderow = _TIFFNoRowEncode;
	140	tif->tif_encodestrip = _TIFFNoStripEncode;
	141	tif->tif_encodetile = _TIFFNoTileEncode;
	142	tif->tif_close = _TIFFvoid;
	143	tif->tif_seek = _TIFFNoSeek;
	144	tif->tif_cleanup = _TIFFvoid;
	145	tif->tif_defstripsize = _TIFFDefaultStripSize;
	146	tif->tif_deftilesize = _TIFFDefaultTileSize;
	147	tif->tif_flags &= ~TIFF_NOBITREV;
	148	}
	149
	150	int
	151	TIFFSetCompressionScheme(TIFF* tif, int scheme)
	152	{
	153	const TIFFCodec *c = TIFFFindCODEC((uint16) scheme);
	154
	155	_TIFFSetDefaultCompressionState(tif);
	156	/*
	157	* Don't treat an unknown compression scheme as an error.
	158	* This permits applications to open files with data that
	159	* the library does not have builtin support for, but which
	160	* may still be meaningful.
	161	*/
	162	return (c ? (*c->init)(tif, scheme) : 1);
	163	}
	164
	165	/*
	166	* Other compression schemes may be registered. Registered
	167	* schemes can also override the builtin versions provided
	168	* by this library.
	169	*/
	170	typedef struct _codec {
	171	struct _codec* next;
	172	TIFFCodec* info;
	173	} codec_t;
	174	static codec_t* registeredCODECS = NULL;
	175
	176	const TIFFCodec*
	177	TIFFFindCODEC(uint16 scheme)
	178	{
	179	const TIFFCodec* c;
	180	codec_t* cd;
	181
	182	for (cd = registeredCODECS; cd; cd = cd->next)
	183	if (cd->info->scheme == scheme)
	184	return ((const TIFFCodec*) cd->info);
	185	for (c = _TIFFBuiltinCODECS; c->name; c++)
	186	if (c->scheme == scheme)
	187	return (c);
	188	return ((const TIFFCodec*) 0);
	189	}
	190
	191	TIFFCodec*
	192	TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
	193	{
	194	codec_t* cd = (codec_t*)
	195	_TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1);
	196
	197	if (cd != NULL) {
	198	cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t));
	199	cd->info->name = (char*)
	200	((tidata_t) cd->info + sizeof (TIFFCodec));
	201	strcpy(cd->info->name, name);
	202	cd->info->scheme = scheme;
	203	cd->info->init = init;
	204	cd->next = registeredCODECS;
	205	registeredCODECS = cd;
	206	} else {
	207	TIFFErrorExt(0, "TIFFRegisterCODEC",
	208	"No space to register compression scheme %s", name);
	209	return NULL;
	210	}
	211	return (cd->info);
	212	}
	213
	214	void
	215	TIFFUnRegisterCODEC(TIFFCodec* c)
	216	{
	217	codec_t* cd;
	218	codec_t** pcd;
	219
	220	for (pcd = &registeredCODECS; (cd = *pcd); pcd = &cd->next)
	221	if (cd->info == c) {
	222	*pcd = cd->next;
	223	_TIFFfree(cd);
	224	return;
	225	}
	226	TIFFErrorExt(0, "TIFFUnRegisterCODEC",
	227	"Cannot remove compression scheme %s; not registered", c->name);
	228	}
	229
	230	/************************************************************************/
	231	/* TIFFGetConfisuredCODECs() */
	232	/************************************************************************/
	233
	234	/**
	235	* Get list of configured codecs, both built-in and registered by user.
	236	* Caller is responsible to free this structure.
	237	*
	238	* @return returns array of TIFFCodec records (the last record should be NULL)
	239	* or NULL if function failed.
	240	*/
	241
	242	TIFFCodec*
	243	TIFFGetConfiguredCODECs()
	244	{
	245	int i = 1;
	246	codec_t *cd;
	247	const TIFFCodec *c;
	248	TIFFCodec codecs = NULL, new_codecs;
	249
	250	for (cd = registeredCODECS; cd; cd = cd->next) {
	251	new_codecs = (TIFFCodec *)
	252	_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
	253	if (!new_codecs) {
	254	_TIFFfree (codecs);
	255	return NULL;
	256	}
	257	codecs = new_codecs;
	258	_TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
	259	i++;
	260	}
	261	for (c = _TIFFBuiltinCODECS; c->name; c++) {
	262	if (TIFFIsCODECConfigured(c->scheme)) {
	263	new_codecs = (TIFFCodec *)
	264	_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
	265	if (!new_codecs) {
	266	_TIFFfree (codecs);
	267	return NULL;
	268	}
	269	codecs = new_codecs;
	270	_TIFFmemcpy(codecs + i - 1, (const tdata_t)c, sizeof(TIFFCodec));
	271	i++;
	272	}
	273	}
	274
	275	new_codecs = (TIFFCodec ) _TIFFrealloc(codecs, i sizeof(TIFFCodec));
	276	if (!new_codecs) {
	277	_TIFFfree (codecs);
	278	return NULL;
	279	}
	280	codecs = new_codecs;
	281	_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
	282
	283	return codecs;
	284	}
	285
	286	/* vim: set ts=8 sts=8 sw=8 noet: */