Preston_PLB/freeswitch
1
0
Fork 0
forked from Mirrors/freeswitch
Code Pull Requests Activity
72a8049835
freeswitch/libs/tiff-4.0.2/tools/thumbnail.c

660 lines
17 KiB
C
Raw Blame History

/* $Id: thumbnail.c,v 1.16 2010-07-02 12:02:56 dron Exp $ */
/*
* Copyright (c) 1994-1997 Sam Leffler
* Copyright (c) 1994-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.
*/
#include "tif_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef NEED_LIBPORT
# include "libport.h"
#endif
#include "tiffio.h"
#ifndef HAVE_GETOPT
extern int getopt(int, char**, char*);
#endif
#define streq(a,b) (strcmp(a,b) == 0)
#ifndef TIFFhowmany8
# define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
#endif
typedef enum {
EXP50,
EXP60,
EXP70,
EXP80,
EXP90,
EXP,
LINEAR
} Contrast;
static uint32 tnw = 216; /* thumbnail width */
static uint32 tnh = 274; /* thumbnail height */
static Contrast contrast = LINEAR; /* current contrast */
static uint8* thumbnail;
static int cpIFD(TIFF*, TIFF*);
static int generateThumbnail(TIFF*, TIFF*);
static void initScale();
static void usage(void);
extern char* optarg;
extern int optind;
int
main(int argc, char* argv[])
{
TIFF* in;
TIFF* out;
int c;
while ((c = getopt(argc, argv, "w:h:c:")) != -1) {
switch (c) {
case 'w': tnw = strtoul(optarg, NULL, 0); break;
case 'h': tnh = strtoul(optarg, NULL, 0); break;
case 'c': contrast = streq(optarg, "exp50") ? EXP50 :
streq(optarg, "exp60") ? EXP60 :
streq(optarg, "exp70") ? EXP70 :
streq(optarg, "exp80") ? EXP80 :
streq(optarg, "exp90") ? EXP90 :
streq(optarg, "exp") ? EXP :
streq(optarg, "linear")? LINEAR :
EXP;
break;
default: usage();
}
}
if (argc-optind != 2)
usage();
out = TIFFOpen(argv[optind+1], "w");
if (out == NULL)
return 2;
in = TIFFOpen(argv[optind], "r");
if( in == NULL )
return 2;
thumbnail = (uint8*) _TIFFmalloc(tnw * tnh);
if (!thumbnail) {
TIFFError(TIFFFileName(in),
"Can't allocate space for thumbnail buffer.");
return 1;
}
if (in != NULL) {
initScale();
do {
if (!generateThumbnail(in, out))
goto bad;
if (!cpIFD(in, out) || !TIFFWriteDirectory(out))
goto bad;
} while (TIFFReadDirectory(in));
(void) TIFFClose(in);
}
(void) TIFFClose(out);
return 0;
bad:
(void) TIFFClose(out);
return 1;
}
#define CopyField(tag, v) \
if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
#define CopyField2(tag, v1, v2) \
if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
#define CopyField3(tag, v1, v2, v3) \
if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
#define CopyField4(tag, v1, v2, v3, v4) \
if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
static void
cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
{
switch (type) {
case TIFF_SHORT:
if (count == 1) {
uint16 shortv;
CopyField(tag, shortv);
} else if (count == 2) {
uint16 shortv1, shortv2;
CopyField2(tag, shortv1, shortv2);
} else if (count == 4) {
uint16 *tr, *tg, *tb, *ta;
CopyField4(tag, tr, tg, tb, ta);
} else if (count == (uint16) -1) {
uint16 shortv1;
uint16* shortav;
CopyField2(tag, shortv1, shortav);
}
break;
case TIFF_LONG:
{ uint32 longv;
CopyField(tag, longv);
}
break;
case TIFF_LONG8:
{ uint64 longv8;
CopyField(tag, longv8);
}
break;
case TIFF_SLONG8:
{ int64 longv8;
CopyField(tag, longv8);
}
break;
case TIFF_RATIONAL:
if (count == 1) {
float floatv;
CopyField(tag, floatv);
} else if (count == (uint16) -1) {
float* floatav;
CopyField(tag, floatav);
}
break;
case TIFF_ASCII:
{ char* stringv;
CopyField(tag, stringv);
}
break;
case TIFF_DOUBLE:
if (count == 1) {
double doublev;
CopyField(tag, doublev);
} else if (count == (uint16) -1) {
double* doubleav;
CopyField(tag, doubleav);
}
break;
case TIFF_IFD8:
{ toff_t ifd8;
CopyField(tag, ifd8);
}
break; default:
TIFFError(TIFFFileName(in),
"Data type %d is not supported, tag %d skipped.",
tag, type);
}
}
#undef CopyField4
#undef CopyField3
#undef CopyField2
#undef CopyField
static struct cpTag {
uint16 tag;
uint16 count;
TIFFDataType type;
} tags[] = {
{ TIFFTAG_IMAGEWIDTH, 1, TIFF_LONG },
{ TIFFTAG_IMAGELENGTH, 1, TIFF_LONG },
{ TIFFTAG_BITSPERSAMPLE, 1, TIFF_SHORT },
{ TIFFTAG_COMPRESSION, 1, TIFF_SHORT },
{ TIFFTAG_FILLORDER, 1, TIFF_SHORT },
{ TIFFTAG_SAMPLESPERPIXEL, 1, TIFF_SHORT },
{ TIFFTAG_ROWSPERSTRIP, 1, TIFF_LONG },
{ TIFFTAG_PLANARCONFIG, 1, TIFF_SHORT },
{ TIFFTAG_GROUP3OPTIONS, 1, TIFF_LONG },
{ TIFFTAG_SUBFILETYPE, 1, TIFF_LONG },
{ TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT },
{ TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT },
{ TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII },
{ TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII },
{ TIFFTAG_MAKE, 1, TIFF_ASCII },
{ TIFFTAG_MODEL, 1, TIFF_ASCII },
{ TIFFTAG_ORIENTATION, 1, TIFF_SHORT },
{ TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT },
{ TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT },
{ TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL },
{ TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL },
{ TIFFTAG_PAGENAME, 1, TIFF_ASCII },
{ TIFFTAG_XPOSITION, 1, TIFF_RATIONAL },
{ TIFFTAG_YPOSITION, 1, TIFF_RATIONAL },
{ TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG },
{ TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT },
{ TIFFTAG_PAGENUMBER, 2, TIFF_SHORT },
{ TIFFTAG_SOFTWARE, 1, TIFF_ASCII },
{ TIFFTAG_DATETIME, 1, TIFF_ASCII },
{ TIFFTAG_ARTIST, 1, TIFF_ASCII },
{ TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII },
{ TIFFTAG_WHITEPOINT, 2, TIFF_RATIONAL },
{ TIFFTAG_PRIMARYCHROMATICITIES, (uint16) -1,TIFF_RATIONAL },
{ TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT },
{ TIFFTAG_BADFAXLINES, 1, TIFF_LONG },
{ TIFFTAG_CLEANFAXDATA, 1, TIFF_SHORT },
{ TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG },
{ TIFFTAG_INKSET, 1, TIFF_SHORT },
{ TIFFTAG_INKNAMES, 1, TIFF_ASCII },
{ TIFFTAG_DOTRANGE, 2, TIFF_SHORT },
{ TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII },
{ TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT },
{ TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL },
{ TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT },
{ TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT },
{ TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL },
{ TIFFTAG_EXTRASAMPLES, (uint16) -1, TIFF_SHORT },
};
#define NTAGS (sizeof (tags) / sizeof (tags[0]))
static void
cpTags(TIFF* in, TIFF* out)
{
struct cpTag *p;
for (p = tags; p < &tags[NTAGS]; p++)
cpTag(in, out, p->tag, p->count, p->type);
}
#undef NTAGS
static int
cpStrips(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFStripSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
tstrip_t s, ns = TIFFNumberOfStrips(in);
uint64 *bytecounts;
TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
for (s = 0; s < ns; s++) {
if (bytecounts[s] > (uint64) bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[s]);
if (!buf)
goto bad;
bufsize = (tmsize_t)bytecounts[s];
}
if (TIFFReadRawStrip(in, s, buf, (tmsize_t)bytecounts[s]) < 0 ||
TIFFWriteRawStrip(out, s, buf, (tmsize_t)bytecounts[s]) < 0) {
_TIFFfree(buf);
return 0;
}
}
_TIFFfree(buf);
return 1;
}
bad:
TIFFError(TIFFFileName(in),
"Can't allocate space for strip buffer.");
return 0;
}
static int
cpTiles(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFTileSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
ttile_t t, nt = TIFFNumberOfTiles(in);
uint64 *bytecounts;
TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts);
for (t = 0; t < nt; t++) {
if (bytecounts[t] > (uint64) bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[t]);
if (!buf)
goto bad;
bufsize = (tmsize_t)bytecounts[t];
}
if (TIFFReadRawTile(in, t, buf, (tmsize_t)bytecounts[t]) < 0 ||
TIFFWriteRawTile(out, t, buf, (tmsize_t)bytecounts[t]) < 0) {
_TIFFfree(buf);
return 0;
}
}
_TIFFfree(buf);
return 1;
}
bad:
TIFFError(TIFFFileName(in),
"Can't allocate space for tile buffer.");
return (0);
}
static int
cpIFD(TIFF* in, TIFF* out)
{
cpTags(in, out);
if (TIFFIsTiled(in)) {
if (!cpTiles(in, out))
return (0);
} else {
if (!cpStrips(in, out))
return (0);
}
return (1);
}
static uint16 photometric; /* current photometric of raster */
static uint16 filterWidth; /* filter width in pixels */
static uint32 stepSrcWidth; /* src image stepping width */
static uint32 stepDstWidth; /* dest stepping width */
static uint8* src0; /* horizontal bit stepping (start) */
static uint8* src1; /* horizontal bit stepping (middle) */
static uint8* src2; /* horizontal bit stepping (end) */
static uint32* rowoff; /* row offset for stepping */
static uint8 cmap[256]; /* colormap indexes */
static uint8 bits[256]; /* count of bits set */
static void
setupBitsTables()
{
int i;
for (i = 0; i < 256; i++) {
int n = 0;
if (i&0x01) n++;
if (i&0x02) n++;
if (i&0x04) n++;
if (i&0x08) n++;
if (i&0x10) n++;
if (i&0x20) n++;
if (i&0x40) n++;
if (i&0x80) n++;
bits[i] = n;
}
}
static int clamp(float v, int low, int high)
{ return (v < low ? low : v > high ? high : (int)v); }
#ifndef M_E
#define M_E 2.7182818284590452354
#endif
static void
expFill(float pct[], uint32 p, uint32 n)
{
uint32 i;
uint32 c = (p * n) / 100;
for (i = 1; i < c; i++)
pct[i] = (float) (1-exp(i/((double)(n-1)))/ M_E);
for (; i < n; i++)
pct[i] = 0.;
}
static void
setupCmap()
{
float pct[256]; /* known to be large enough */
uint32 i;
pct[0] = 1; /* force white */
switch (contrast) {
case EXP50: expFill(pct, 50, 256); break;
case EXP60: expFill(pct, 60, 256); break;
case EXP70: expFill(pct, 70, 256); break;
case EXP80: expFill(pct, 80, 256); break;
case EXP90: expFill(pct, 90, 256); break;
case EXP: expFill(pct, 100, 256); break;
case LINEAR:
for (i = 1; i < 256; i++)
pct[i] = 1-((float)i)/(256-1);
break;
}
switch (photometric) {
case PHOTOMETRIC_MINISWHITE:
for (i = 0; i < 256; i++)
cmap[i] = clamp(255*pct[(256-1)-i], 0, 255);
break;
case PHOTOMETRIC_MINISBLACK:
for (i = 0; i < 256; i++)
cmap[i] = clamp(255*pct[i], 0, 255);
break;
}
}
static void
initScale()
{
src0 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
src1 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
src2 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
rowoff = (uint32*) _TIFFmalloc(sizeof (uint32) * tnw);
filterWidth = 0;
stepDstWidth = stepSrcWidth = 0;
setupBitsTables();
}
/*
* Calculate the horizontal accumulation parameteres
* according to the widths of the src and dst images.
*/
static void
setupStepTables(uint32 sw)
{
if (stepSrcWidth != sw || stepDstWidth != tnw) {
int step = sw;
int limit = tnw;
int err = 0;
uint32 sx = 0;
uint32 x;
int fw;
uint8 b;
for (x = 0; x < tnw; x++) {
uint32 sx0 = sx;
err += step;
while (err >= limit) {
err -= limit;
sx++;
}
rowoff[x] = sx0 >> 3;
fw = sx - sx0; /* width */
b = (fw < 8) ? 0xff<<(8-fw) : 0xff;
src0[x] = b >> (sx0&7);
fw -= 8 - (sx0&7);
if (fw < 0)
fw = 0;
src1[x] = fw >> 3;
fw -= (fw>>3)<<3;
src2[x] = 0xff << (8-fw);
}
stepSrcWidth = sw;
stepDstWidth = tnw;
}
}
static void
setrow(uint8* row, uint32 nrows, const uint8* rows[])
{
uint32 x;
uint32 area = nrows * filterWidth;
for (x = 0; x < tnw; x++) {
uint32 mask0 = src0[x];
uint32 fw = src1[x];
uint32 mask1 = src1[x];
uint32 off = rowoff[x];
uint32 acc = 0;
uint32 y, i;
for (y = 0; y < nrows; y++) {
const uint8* src = rows[y] + off;
acc += bits[*src++ & mask0];
switch (fw) {
default:
for (i = fw; i > 8; i--)
acc += bits[*src++];
/* fall thru... */
case 8: acc += bits[*src++];
case 7: acc += bits[*src++];
case 6: acc += bits[*src++];
case 5: acc += bits[*src++];
case 4: acc += bits[*src++];
case 3: acc += bits[*src++];
case 2: acc += bits[*src++];
case 1: acc += bits[*src++];
case 0: break;
}
acc += bits[*src & mask1];
}
*row++ = cmap[(255*acc)/area];
}
}
/*
* Install the specified image. The
* image is resized to fit the display page using
* a box filter. The resultant pixels are mapped
* with a user-selectable contrast curve.
*/
static void
setImage1(const uint8* br, uint32 rw, uint32 rh)
{
int step = rh;
int limit = tnh;
int err = 0;
int bpr = TIFFhowmany8(rw);
int sy = 0;
uint8* row = thumbnail;
uint32 dy;
for (dy = 0; dy < tnh; dy++) {
const uint8* rows[256];
uint32 nrows = 1;
fprintf(stderr, "bpr=%d, sy=%d, bpr*sy=%d\n", bpr, sy, bpr*sy);
rows[0] = br + bpr*sy;
err += step;
while (err >= limit) {
err -= limit;
sy++;
if (err >= limit)
rows[nrows++] = br + bpr*sy;
}
setrow(row, nrows, rows);
row += tnw;
}
}
static void
setImage(const uint8* br, uint32 rw, uint32 rh)
{
filterWidth = (uint16) ceil((double) rw / (double) tnw);
setupStepTables(rw);
setImage1(br, rw, rh);
}
static int
generateThumbnail(TIFF* in, TIFF* out)
{
unsigned char* raster;
unsigned char* rp;
uint32 sw, sh, rps;
uint16 bps, spp;
tsize_t rowsize, rastersize;
tstrip_t s, ns = TIFFNumberOfStrips(in);
toff_t diroff[1];
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &sw);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &sh);
TIFFGetFieldDefaulted(in, TIFFTAG_BITSPERSAMPLE, &bps);
TIFFGetFieldDefaulted(in, TIFFTAG_SAMPLESPERPIXEL, &spp);
TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps);
if (spp != 1 || bps != 1)
return 0;
rowsize = TIFFScanlineSize(in);
rastersize = sh * rowsize;
fprintf(stderr, "rastersize=%u\n", (unsigned int)rastersize);
raster = (unsigned char*)_TIFFmalloc(rastersize);
if (!raster) {
TIFFError(TIFFFileName(in),
"Can't allocate space for raster buffer.");
return 0;
}
rp = raster;
for (s = 0; s < ns; s++) {
(void) TIFFReadEncodedStrip(in, s, rp, -1);
rp += rps * rowsize;
}
TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &photometric);
setupCmap();
setImage(raster, sw, sh);
_TIFFfree(raster);
TIFFSetField(out, TIFFTAG_SUBFILETYPE, FILETYPE_REDUCEDIMAGE);
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, (uint32) tnw);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, (uint32) tnh);
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, (uint16) 8);
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, (uint16) 1);
TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
cpTag(in, out, TIFFTAG_SOFTWARE, (uint16) -1, TIFF_ASCII);
cpTag(in, out, TIFFTAG_IMAGEDESCRIPTION, (uint16) -1, TIFF_ASCII);
cpTag(in, out, TIFFTAG_DATETIME, (uint16) -1, TIFF_ASCII);
cpTag(in, out, TIFFTAG_HOSTCOMPUTER, (uint16) -1, TIFF_ASCII);
diroff[0] = 0UL;
TIFFSetField(out, TIFFTAG_SUBIFD, 1, diroff);
return (TIFFWriteEncodedStrip(out, 0, thumbnail, tnw*tnh) != -1 &&
TIFFWriteDirectory(out) != -1);
}
char* stuff[] = {
"usage: thumbnail [options] input.tif output.tif",
"where options are:",
" -h # specify thumbnail image height (default is 274)",
" -w # specify thumbnail image width (default is 216)",
"",
" -c linear use linear contrast curve",
" -c exp50 use 50% exponential contrast curve",
" -c exp60 use 60% exponential contrast curve",
" -c exp70 use 70% exponential contrast curve",
" -c exp80 use 80% exponential contrast curve",
" -c exp90 use 90% exponential contrast curve",
" -c exp use pure exponential contrast curve",
NULL
};
static void
usage(void)
{
char buf[BUFSIZ];
int i;
setbuf(stderr, buf);
fprintf(stderr, "%s\n\n", TIFFGetVersion());
for (i = 0; stuff[i] != NULL; i++)
fprintf(stderr, "%s\n", stuff[i]);
exit(-1);
}
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/
View Git Blame Copy Permalink