| OLD | NEW |
|---|
| (Empty) |
| 1 /* $Id: tif_compress.c,v 1.22 2010-03-10 18:56:48 bfriesen Exp $ */ | |
| 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, | |
| 41 "%s %s encoding is not implemented", | |
| 42 c->name, method); | |
| 43 } else { | |
| 44 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, | |
| 45 "Compression scheme %u %s encoding is not implemented", | |
| 46 tif->tif_dir.td_compression, method); | |
| 47 } | |
| 48 return (-1); | |
| 49 } | |
| 50 | |
| 51 int | |
| 52 _TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 53 { | |
| 54 (void) pp; (void) cc; (void) s; | |
| 55 return (TIFFNoEncode(tif, "scanline")); | |
| 56 } | |
| 57 | |
| 58 int | |
| 59 _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 60 { | |
| 61 (void) pp; (void) cc; (void) s; | |
| 62 return (TIFFNoEncode(tif, "strip")); | |
| 63 } | |
| 64 | |
| 65 int | |
| 66 _TIFFNoTileEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 67 { | |
| 68 (void) pp; (void) cc; (void) s; | |
| 69 return (TIFFNoEncode(tif, "tile")); | |
| 70 } | |
| 71 | |
| 72 static int | |
| 73 TIFFNoDecode(TIFF* tif, const char* method) | |
| 74 { | |
| 75 const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); | |
| 76 | |
| 77 if (c) | |
| 78 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, | |
| 79 "%s %s decoding is not implemented", | |
| 80 c->name, method); | |
| 81 else | |
| 82 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, | |
| 83 "Compression scheme %u %s decoding is not implement
ed", | |
| 84 tif->tif_dir.td_compression, method); | |
| 85 return (-1); | |
| 86 } | |
| 87 | |
| 88 int | |
| 89 _TIFFNoFixupTags(TIFF* tif) | |
| 90 { | |
| 91 (void) tif; | |
| 92 return (1); | |
| 93 } | |
| 94 | |
| 95 int | |
| 96 _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 97 { | |
| 98 (void) pp; (void) cc; (void) s; | |
| 99 return (TIFFNoDecode(tif, "scanline")); | |
| 100 } | |
| 101 | |
| 102 int | |
| 103 _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 104 { | |
| 105 (void) pp; (void) cc; (void) s; | |
| 106 return (TIFFNoDecode(tif, "strip")); | |
| 107 } | |
| 108 | |
| 109 int | |
| 110 _TIFFNoTileDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) | |
| 111 { | |
| 112 (void) pp; (void) cc; (void) s; | |
| 113 return (TIFFNoDecode(tif, "tile")); | |
| 114 } | |
| 115 | |
| 116 int | |
| 117 _TIFFNoSeek(TIFF* tif, uint32 off) | |
| 118 { | |
| 119 (void) off; | |
| 120 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, | |
| 121 "Compression algorithm does not support random access"); | |
| 122 return (0); | |
| 123 } | |
| 124 | |
| 125 int | |
| 126 _TIFFNoPreCode(TIFF* tif, uint16 s) | |
| 127 { | |
| 128 (void) tif; (void) s; | |
| 129 return (1); | |
| 130 } | |
| 131 | |
| 132 static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); } | |
| 133 static void _TIFFvoid(TIFF* tif) { (void) tif; } | |
| 134 | |
| 135 void | |
| 136 _TIFFSetDefaultCompressionState(TIFF* tif) | |
| 137 { | |
| 138 tif->tif_fixuptags = _TIFFNoFixupTags; | |
| 139 tif->tif_decodestatus = TRUE; | |
| 140 tif->tif_setupdecode = _TIFFtrue; | |
| 141 tif->tif_predecode = _TIFFNoPreCode; | |
| 142 tif->tif_decoderow = _TIFFNoRowDecode; | |
| 143 tif->tif_decodestrip = _TIFFNoStripDecode; | |
| 144 tif->tif_decodetile = _TIFFNoTileDecode; | |
| 145 tif->tif_encodestatus = TRUE; | |
| 146 tif->tif_setupencode = _TIFFtrue; | |
| 147 tif->tif_preencode = _TIFFNoPreCode; | |
| 148 tif->tif_postencode = _TIFFtrue; | |
| 149 tif->tif_encoderow = _TIFFNoRowEncode; | |
| 150 tif->tif_encodestrip = _TIFFNoStripEncode; | |
| 151 tif->tif_encodetile = _TIFFNoTileEncode; | |
| 152 tif->tif_close = _TIFFvoid; | |
| 153 tif->tif_seek = _TIFFNoSeek; | |
| 154 tif->tif_cleanup = _TIFFvoid; | |
| 155 tif->tif_defstripsize = _TIFFDefaultStripSize; | |
| 156 tif->tif_deftilesize = _TIFFDefaultTileSize; | |
| 157 tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW); | |
| 158 } | |
| 159 | |
| 160 int | |
| 161 TIFFSetCompressionScheme(TIFF* tif, int scheme) | |
| 162 { | |
| 163 const TIFFCodec *c = TIFFFindCODEC((uint16) scheme); | |
| 164 | |
| 165 _TIFFSetDefaultCompressionState(tif); | |
| 166 /* | |
| 167 * Don't treat an unknown compression scheme as an error. | |
| 168 * This permits applications to open files with data that | |
| 169 * the library does not have builtin support for, but which | |
| 170 * may still be meaningful. | |
| 171 */ | |
| 172 return (c ? (*c->init)(tif, scheme) : 1); | |
| 173 } | |
| 174 | |
| 175 /* | |
| 176 * Other compression schemes may be registered. Registered | |
| 177 * schemes can also override the builtin versions provided | |
| 178 * by this library. | |
| 179 */ | |
| 180 typedef struct _codec { | |
| 181 struct _codec* next; | |
| 182 TIFFCodec* info; | |
| 183 } codec_t; | |
| 184 static codec_t* registeredCODECS = NULL; | |
| 185 | |
| 186 const TIFFCodec* | |
| 187 TIFFFindCODEC(uint16 scheme) | |
| 188 { | |
| 189 const TIFFCodec* c; | |
| 190 codec_t* cd; | |
| 191 | |
| 192 for (cd = registeredCODECS; cd; cd = cd->next) | |
| 193 if (cd->info->scheme == scheme) | |
| 194 return ((const TIFFCodec*) cd->info); | |
| 195 for (c = _TIFFBuiltinCODECS; c->name; c++) | |
| 196 if (c->scheme == scheme) | |
| 197 return (c); | |
| 198 return ((const TIFFCodec*) 0); | |
| 199 } | |
| 200 | |
| 201 TIFFCodec* | |
| 202 TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init) | |
| 203 { | |
| 204 codec_t* cd = (codec_t*) | |
| 205 _TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strle
n(name)+1)); | |
| 206 | |
| 207 if (cd != NULL) { | |
| 208 cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t)); | |
| 209 cd->info->name = (char*) | |
| 210 ((uint8*) cd->info + sizeof (TIFFCodec)); | |
| 211 strcpy(cd->info->name, name); | |
| 212 cd->info->scheme = scheme; | |
| 213 cd->info->init = init; | |
| 214 cd->next = registeredCODECS; | |
| 215 registeredCODECS = cd; | |
| 216 } else { | |
| 217 TIFFErrorExt(0, "TIFFRegisterCODEC", | |
| 218 "No space to register compression scheme %s", name); | |
| 219 return NULL; | |
| 220 } | |
| 221 return (cd->info); | |
| 222 } | |
| 223 | |
| 224 void | |
| 225 TIFFUnRegisterCODEC(TIFFCodec* c) | |
| 226 { | |
| 227 codec_t* cd; | |
| 228 codec_t** pcd; | |
| 229 | |
| 230 for (pcd = ®isteredCODECS; (cd = *pcd); pcd = &cd->next) | |
| 231 if (cd->info == c) { | |
| 232 *pcd = cd->next; | |
| 233 _TIFFfree(cd); | |
| 234 return; | |
| 235 } | |
| 236 TIFFErrorExt(0, "TIFFUnRegisterCODEC", | |
| 237 "Cannot remove compression scheme %s; not registered", c->name); | |
| 238 } | |
| 239 | |
| 240 /************************************************************************/ | |
| 241 /* TIFFGetConfisuredCODECs() */ | |
| 242 /************************************************************************/ | |
| 243 | |
| 244 /** | |
| 245 * Get list of configured codecs, both built-in and registered by user. | |
| 246 * Caller is responsible to free this structure. | |
| 247 * | |
| 248 * @return returns array of TIFFCodec records (the last record should be NULL) | |
| 249 * or NULL if function failed. | |
| 250 */ | |
| 251 | |
| 252 TIFFCodec* | |
| 253 TIFFGetConfiguredCODECs() | |
| 254 { | |
| 255 int i = 1; | |
| 256 codec_t *cd; | |
| 257 const TIFFCodec* c; | |
| 258 TIFFCodec* codecs = NULL; | |
| 259 TIFFCodec* new_codecs; | |
| 260 | |
| 261 for (cd = registeredCODECS; cd; cd = cd->next) { | |
| 262 new_codecs = (TIFFCodec *) | |
| 263 _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); | |
| 264 if (!new_codecs) { | |
| 265 _TIFFfree (codecs); | |
| 266 return NULL; | |
| 267 } | |
| 268 codecs = new_codecs; | |
| 269 _TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec)); | |
| 270 i++; | |
| 271 } | |
| 272 for (c = _TIFFBuiltinCODECS; c->name; c++) { | |
| 273 if (TIFFIsCODECConfigured(c->scheme)) { | |
| 274 new_codecs = (TIFFCodec *) | |
| 275 _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); | |
| 276 if (!new_codecs) { | |
| 277 _TIFFfree (codecs); | |
| 278 return NULL; | |
| 279 } | |
| 280 codecs = new_codecs; | |
| 281 _TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFC
odec)); | |
| 282 i++; | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); | |
| 287 if (!new_codecs) { | |
| 288 _TIFFfree (codecs); | |
| 289 return NULL; | |
| 290 } | |
| 291 codecs = new_codecs; | |
| 292 _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec)); | |
| 293 | |
| 294 return codecs; | |
| 295 } | |
| 296 | |
| 297 /* vim: set ts=8 sts=8 sw=8 noet: */ | |
| 298 /* | |
| 299 * Local Variables: | |
| 300 * mode: c | |
| 301 * c-basic-offset: 8 | |
| 302 * fill-column: 78 | |
| 303 * End: | |
| 304 */ | |
| 305 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1563103002:
XFA: Upgrade to libtiff 4.0.6. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@xfa