third_party/libtiff/tif_compress.c - pdfium - Git at Google

 /*
  * 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;
 }
	/*
	* 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;
	}